From 8d933ce83d251c58112e90221d5bd9d0754b27e6 Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Sun, 21 Feb 2021 13:04:31 -0800 Subject: [PATCH] chore: update stage0 --- stage0/src/Init/Control/Except.lean | 21 +- stage0/src/Init/Control/Lawful.lean | 222 + stage0/src/Init/Core.lean | 9 +- stage0/src/Init/Prelude.lean | 12 +- stage0/src/Lean/Util/ReplaceExpr.lean | 2 +- stage0/stdlib/CMakeLists.txt | 2 +- stage0/stdlib/Init/Control/Except.c | 70 +- stage0/stdlib/Init/Control/Lawful.c | 45 +- stage0/stdlib/Lean/Elab/Inductive.c | 1285 +++--- stage0/stdlib/Lean/Elab/MutualDef.c | 1251 +++--- stage0/stdlib/Lean/Elab/PreDefinition/Basic.c | 3795 ++++++++--------- stage0/stdlib/Lean/Meta/Match/MVarRenaming.c | 1262 +++--- stage0/stdlib/Lean/Meta/Tactic/FVarSubst.c | 1260 +++--- stage0/stdlib/Lean/ParserCompiler.c | 1323 +++--- stage0/stdlib/Lean/Util/ReplaceExpr.c | 1273 +++--- stage0/stdlib/Std/Control/Lawful.c | 29 - 16 files changed, 5801 insertions(+), 6060 deletions(-) delete mode 100644 stage0/stdlib/Std/Control/Lawful.c diff --git a/stage0/src/Init/Control/Except.lean b/stage0/src/Init/Control/Except.lean index 9303cf8797..13fd5ec154 100644 --- a/stage0/src/Init/Control/Except.lean +++ b/stage0/src/Init/Control/Except.lean @@ -10,36 +10,39 @@ import Init.Control.Basic import Init.Control.Id import Init.Coe -universes u v w u' - namespace Except variable {ε : Type u} -@[inline] protected def pure {α : Type v} (a : α) : Except ε α := +@[inline] protected def pure (a : α) : Except ε α := Except.ok a -@[inline] protected def map {α β : Type v} (f : α → β) : Except ε α → Except ε β +@[inline] protected def map (f : α → β) : Except ε α → Except ε β | Except.error err => Except.error err | Except.ok v => Except.ok <| f v -@[inline] protected def mapError {ε' : Type u} {α : Type v} (f : ε → ε') : Except ε α → Except ε' α +@[simp] theorem map_id : Except.map (ε := ε) (α := α) (β := α) id = id := by + apply funext + intro e + simp [Except.map]; cases e <;> rfl + +@[inline] protected def mapError (f : ε → ε') : Except ε α → Except ε' α | Except.error err => Except.error <| f err | Except.ok v => Except.ok v -@[inline] protected def bind {α β : Type v} (ma : Except ε α) (f : α → Except ε β) : Except ε β := +@[inline] protected def bind (ma : Except ε α) (f : α → Except ε β) : Except ε β := match ma with | Except.error err => Except.error err | Except.ok v => f v -@[inline] protected def toBool {α : Type v} : Except ε α → Bool +@[inline] protected def toBool : Except ε α → Bool | Except.ok _ => true | Except.error _ => false -@[inline] protected def toOption {α : Type v} : Except ε α → Option α +@[inline] protected def toOption : Except ε α → Option α | Except.ok a => some a | Except.error _ => none -@[inline] protected def tryCatch {α : Type u} (ma : Except ε α) (handle : ε → Except ε α) : Except ε α := +@[inline] protected def tryCatch (ma : Except ε α) (handle : ε → Except ε α) : Except ε α := match ma with | Except.ok a => Except.ok a | Except.error e => handle e diff --git a/stage0/src/Init/Control/Lawful.lean b/stage0/src/Init/Control/Lawful.lean index 5727347b3a..313c9d785c 100644 --- a/stage0/src/Init/Control/Lawful.lean +++ b/stage0/src/Init/Control/Lawful.lean @@ -5,6 +5,8 @@ Authors: Sebastian Ullrich, Leonardo de Moura -/ prelude import Init.SimpLemmas +import Init.Control.Except +import Init.Control.StateRef open Function @@ -17,6 +19,9 @@ export LawfulFunctor (map_const id_map comp_map) attribute [simp] id_map +@[simp] theorem id_map' [Functor m] [LawfulFunctor m] (x : m α) : (fun a => a) <$> x = x := + id_map x + class LawfulApplicative (f : Type u → Type v) [Applicative f] extends LawfulFunctor f : Prop where seqLeft_eq (x : f α) (y : f β) : x <* y = const β <$> x <*> y seqRight_eq (x : f α) (y : f β) : x *> y = const α id <$> x <*> y @@ -24,6 +29,9 @@ class LawfulApplicative (f : Type u → Type v) [Applicative f] extends LawfulFu map_pure (g : α → β) (x : α) : g <$> (pure x : f α) = pure (g x) seq_pure (g : f (α → β)) (x : α) : g <*> pure x = (fun h : α → β => h x) <$> g seq_assoc (x : f α) (g : f (α → β)) (h : f (β → γ)) : h <*> (g <*> x) = (@comp α β γ <$> h) <*> g <*> x + comp_map g h x := by + repeat rw [← pure_seq] + simp [seq_assoc, map_pure, seq_pure] export LawfulApplicative (seqLeft_eq seqRight_eq pure_seq map_pure seq_pure seq_assoc) @@ -37,6 +45,15 @@ class LawfulMonad (m : Type u → Type v) [Monad m] extends LawfulApplicative m bind_map (f : m (α → (β : Type u))) (x : m α) : f >>= (. <$> x) = f <*> x pure_bind (x : α) (f : α → m β) : pure x >>= f = f x bind_assoc (x : m α) (f : α → m β) (g : β → m γ) : x >>= f >>= g = x >>= fun x => f x >>= g + map_pure g x := by rw [← bind_pure_comp, pure_bind] + seq_pure g x := by rw [← bind_map]; simp [map_pure, bind_pure_comp] + seq_assoc x g h := by + -- TODO: support for applying `symm` at `simp` arguments + let bind_pure_comp_symm {α β : Type u} (f : α → β) (x : m α) : f <$> x = x >>= pure ∘ f := by + rw [bind_pure_comp] + let bind_map_symm {α β : Type u} (f : m (α → (β : Type u))) (x : m α) : f <*> x = f >>= (. <$> x) := by + rw [bind_map] + simp[bind_pure_comp_symm, bind_map_symm, bind_assoc, pure_bind] export LawfulMonad (bind_pure_comp bind_map pure_bind bind_assoc) attribute [simp] pure_bind bind_assoc @@ -53,3 +70,208 @@ theorem bind_congr [Bind m] {x : m α} {f g : α → m β} (h : ∀ a, f a = g a theorem map_congr [Functor m] {x : m α} {f g : α → β} (h : ∀ a, f a = g a) : (f <$> x : m β) = g <$> x := by simp [funext h] + +theorem seq_eq_bind {α β : Type u} [Monad m] [LawfulMonad m] (mf : m (α → β)) (x : m α) : mf <*> x = mf >>= fun f => f <$> x := by + rw [bind_map] + +theorem seqRight_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x *> y = x >>= fun _ => y := by + rw [seqRight_eq, ← bind_map, ← bind_pure_comp] + simp [Function.const] + +theorem seqLeft_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x <* y = x >>= fun a => y >>= fun _ => pure a := by + rw [seqLeft_eq, ← bind_map, ← bind_pure_comp] + simp + apply bind_congr; intro + rw [← bind_pure_comp] + +/- Id -/ + +namespace Id + +@[simp] theorem map_eq (x : Id α) (f : α → β) : f <$> x = f x := rfl +@[simp] theorem bind_eq (x : Id α) (f : α → id β) : x >>= f = f x := rfl +@[simp] theorem pure_eq (a : α) : (pure a : Id α) = a := rfl + +instance : LawfulMonad Id := by + refine! { .. } <;> intros <;> rfl + +end Id + +/- ExceptT -/ + +namespace ExceptT + +theorem ext [Monad m] {x y : ExceptT ε m α} (h : x.run = y.run) : x = y := by + simp [run] at h + assumption + +@[simp] theorem run_pure [Monad m] : run (pure x : ExceptT ε m α) = pure (Except.ok x) := rfl +@[simp] theorem run_lift [Monad m] : run (ExceptT.lift x : ExceptT ε m α) = Except.ok <$> x := rfl +@[simp] theorem run_throw [Monad m] : run (throw e : ExceptT ε m β) = pure (Except.error e) := rfl +@[simp] theorem run_bind [Monad m] (x : ExceptT ε m α) + : run (x >>= f : ExceptT ε m β) + = + run x >>= fun + | Except.ok x => run (f x) + | Except.error e => pure (Except.error e) := + rfl + +@[simp] theorem lift_pure [Monad m] [LawfulMonad m] (a : α) : ExceptT.lift (pure a) = (pure a : ExceptT ε m α) := by + simp [ExceptT.lift, pure, ExceptT.pure] + +@[simp] theorem run_map [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α) + : (f <$> x).run = Except.map f <$> x.run := by + rw [← bind_pure_comp (m := m)] + simp [Functor.map, ExceptT.map] + apply bind_congr + intro a; cases a <;> simp [Except.map] + +protected theorem seq_eq {α β ε : Type u} [Monad m] (mf : ExceptT ε m (α → β)) (x : ExceptT ε m α) : mf <*> x = mf >>= fun f => f <$> x := + rfl + +protected theorem bind_pure_comp [Monad m] [LawfulMonad m] (f : α → β) (x : ExceptT ε m α) : x >>= pure ∘ f = f <$> x := by + intros; rfl + +protected theorem seqLeft_eq {α β ε : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) : x <* y = const β <$> x <*> y := by + show (x >>= fun a => y >>= fun _ => pure a) = (const (α := α) β <$> x) >>= fun f => f <$> y + rw [← ExceptT.bind_pure_comp] + apply ext + simp + apply bind_congr + intro a + cases a with + | error => simp + | ok => + simp; rw [← bind_pure_comp]; apply bind_congr; intro b; + cases b <;> simp [comp, Except.map, const] + +protected theorem seqRight_eq [Monad m] [LawfulMonad m] (x : ExceptT ε m α) (y : ExceptT ε m β) : x *> y = const α id <$> x <*> y := by + show (x >>= fun _ => y) = (const α id <$> x) >>= fun f => f <$> y + rw [← ExceptT.bind_pure_comp] + apply ext + simp + apply bind_congr + intro a; cases a <;> simp + +instance [Monad m] [LawfulMonad m] : LawfulMonad (ExceptT ε m) where + id_map := by intros; apply ext; simp + map_const := by intros; rfl + seqLeft_eq := ExceptT.seqLeft_eq + seqRight_eq := ExceptT.seqRight_eq + pure_seq := by intros; apply ext; simp [ExceptT.seq_eq] + bind_pure_comp := ExceptT.bind_pure_comp + bind_map := by intros; rfl + pure_bind := by intros; apply ext; simp + bind_assoc := by intros; apply ext; simp; apply bind_congr; intro a; cases a <;> simp + +end ExceptT + +/- ReaderT -/ + +namespace ReaderT + +theorem ext [Monad m] {x y : ReaderT ρ m α} (h : ∀ ctx, x.run ctx = y.run ctx) : x = y := by + simp [run] at h + exact funext h + +@[simp] theorem run_pure [Monad m] (a : α) (ctx : ρ) : (pure a : ReaderT ρ m α).run ctx = pure a := rfl +@[simp] theorem run_bind [Monad m] (x : ReaderT ρ m α) (f : α → ReaderT ρ m β) (ctx : ρ) + : (x >>= f).run ctx = x.run ctx >>= λ a => (f a).run ctx := rfl +@[simp] theorem run_map [Monad m] (f : α → β) (x : ReaderT ρ m α) (ctx : ρ) + : (f <$> x).run ctx = f <$> x.run ctx := rfl +@[simp] theorem run_monadLift [MonadLiftT n m] (x : n α) (ctx : ρ) + : (monadLift x : ReaderT ρ m α).run ctx = (monadLift x : m α) := rfl +@[simp] theorem run_monadMap [Monad m] [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : ReaderT ρ m α) (ctx : ρ) + : (monadMap @f x : ReaderT ρ m α).run ctx = monadMap @f (x.run ctx) := rfl +@[simp] theorem run_read [Monad m] (ctx : ρ) : (ReaderT.read : ReaderT ρ m ρ).run ctx = pure ctx := rfl +@[simp] theorem run_seq {α β : Type u} [Monad m] [LawfulMonad m] (f : ReaderT ρ m (α → β)) (x : ReaderT ρ m α) (ctx : ρ) : (f <*> x).run ctx = (f.run ctx <*> x.run ctx) := by + rw [seq_eq_bind (m := m)]; rfl +@[simp] theorem run_seqRight [Monad m] [LawfulMonad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ) : (x *> y).run ctx = (x.run ctx *> y.run ctx) := by + rw [seqRight_eq_bind (m := m)]; rfl +@[simp] theorem run_seqLeft [Monad m] [LawfulMonad m] (x : ReaderT ρ m α) (y : ReaderT ρ m β) (ctx : ρ) : (x <* y).run ctx = (x.run ctx <* y.run ctx) := by + rw [seqLeft_eq_bind (m := m)]; rfl + +instance [Monad m] [LawfulMonad m] : LawfulMonad (ReaderT ρ m) where + id_map := by intros; apply ext; intros; simp + map_const := by intros; rfl + seqLeft_eq := by intros; apply ext; intros; simp; apply LawfulApplicative.seqLeft_eq + seqRight_eq := by intros; apply ext; intros; simp; apply LawfulApplicative.seqRight_eq + pure_seq := by intros; apply ext; intros; simp; apply LawfulApplicative.pure_seq + bind_pure_comp := by intros; apply ext; intros; simp; apply LawfulMonad.bind_pure_comp + bind_map := by intros; rfl + pure_bind := by intros; apply ext; intros; simp + bind_assoc := by intros; apply ext; intros; simp + +end ReaderT + +/- StateRefT -/ + +instance [Monad m] [LawfulMonad m] : LawfulMonad (StateRefT' ω σ m) := + inferInstanceAs (LawfulMonad (ReaderT (ST.Ref ω σ) m)) + +/- StateT -/ + +namespace StateT + +theorem ext {x y : StateT σ m α} (h : ∀ s, x.run s = y.run s) : x = y := + funext h + +@[simp] theorem run_pure [Monad m] (a : α) (s : σ) : (pure a : StateT σ m α).run s = pure (a, s) := rfl + +@[simp] theorem run_bind [Monad m] (x : StateT σ m α) (f : α → StateT σ m β) (s : σ) + : (x >>= f).run s = x.run s >>= λ p => (f p.1).run p.2 := by + simp [bind, StateT.bind, run] + apply bind_congr + intro p; cases p; rfl + +@[simp] theorem run_map {α β σ : Type u} [Monad m] [LawfulMonad m] (f : α → β) (x : StateT σ m α) (s : σ) : (f <$> x).run s = (fun (p : α × σ) => (f p.1, p.2)) <$> x.run s := by + simp [Functor.map, StateT.map, run] + rw [← bind_pure_comp] + apply bind_congr + intro p; cases p; rfl + +@[simp] theorem run_get [Monad m] (s : σ) : (get : StateT σ m σ).run s = pure (s, s) := rfl + +@[simp] theorem run_set [Monad m] (s s' : σ) : (set s' : StateT σ m PUnit).run s = pure (⟨⟩, s') := rfl + +@[simp] theorem run_monadLift [Monad m] [MonadLiftT n m] (x : n α) (s : σ) : (monadLift x : StateT σ m α).run s = (monadLift x : m α) >>= fun a => pure (a, s) := rfl + +@[simp] theorem run_monadMap [Monad m] [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : StateT σ m α) (s : σ) + : (monadMap @f x : StateT σ m α).run s = monadMap @f (x.run s) := rfl + +@[simp] theorem run_seq {α β σ : Type u} [Monad m] [LawfulMonad m] (f : StateT σ m (α → β)) (x : StateT σ m α) (s : σ) : (f <*> x).run s = (f.run s >>= fun fs => (fun (p : α × σ) => (fs.1 p.1, p.2)) <$> x.run fs.2) := by + show (f >>= fun g => g <$> x).run s = _ + simp + +@[simp] theorem run_seqRight [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ) : (x *> y).run s = (x.run s >>= fun p => y.run p.2) := by + show (x >>= fun _ => y).run s = _ + simp + +@[simp] theorem run_seqLeft {α β σ : Type u} [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) (s : σ) : (x <* y).run s = (x.run s >>= fun p => y.run p.2 >>= fun p' => pure (p.1, p'.2)) := by + show (x >>= fun a => y >>= fun _ => pure a).run s = _ + simp + +theorem seqRight_eq [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) : x *> y = const α id <$> x <*> y := by + apply ext; intro s + simp; rw [← bind_pure_comp]; simp + apply bind_congr; intro p; cases p + simp[Prod.ext] + +theorem seqLeft_eq [Monad m] [LawfulMonad m] (x : StateT σ m α) (y : StateT σ m β) : x <* y = const β <$> x <*> y := by + apply ext; intro s + simp; rw [← bind_pure_comp]; simp + apply bind_congr; intro p; cases p + simp[Prod.ext, const]; rw [← bind_pure_comp] + +instance [Monad m] [LawfulMonad m] : LawfulMonad (StateT σ m) where + id_map := by intros; apply ext; intros; simp[Prod.ext] + map_const := by intros; rfl + seqLeft_eq := seqLeft_eq + seqRight_eq := seqRight_eq + pure_seq := by intros; apply ext; intros; simp + bind_pure_comp := by intros; apply ext; intros; simp; apply LawfulMonad.bind_pure_comp + bind_map := by intros; rfl + pure_bind := by intros; apply ext; intros; simp + bind_assoc := by intros; apply ext; intros; simp + +end StateT diff --git a/stage0/src/Init/Core.lean b/stage0/src/Init/Core.lean index de20f01541..8eae03ab07 100644 --- a/stage0/src/Init/Core.lean +++ b/stage0/src/Init/Core.lean @@ -556,9 +556,6 @@ end /- Product -/ -section -variable {α : Type u} {β : Type v} - instance [Inhabited α] [Inhabited β] : Inhabited (α × β) where default := (arbitrary, arbitrary) @@ -585,9 +582,11 @@ instance prodHasDecidableLt theorem Prod.ltDef [HasLess α] [HasLess β] (s t : α × β) : (s < t) = (s.1 < t.1 ∨ (s.1 = t.1 ∧ s.2 < t.2)) := rfl -end -def Prod.map.{u₁, u₂, v₁, v₂} {α₁ : Type u₁} {α₂ : Type u₂} {β₁ : Type v₁} {β₂ : Type v₂} +theorem Prod.ext (p : α × β) : (p.1, p.2) = p := by + cases p; rfl + +def Prod.map {α₁ : Type u₁} {α₂ : Type u₂} {β₁ : Type v₁} {β₂ : Type v₂} (f : α₁ → α₂) (g : β₁ → β₂) : α₁ × β₁ → α₂ × β₂ | (a, b) => (f a, g b) diff --git a/stage0/src/Init/Prelude.lean b/stage0/src/Init/Prelude.lean index bd26ea7e11..b04bd24b84 100644 --- a/stage0/src/Init/Prelude.lean +++ b/stage0/src/Init/Prelude.lean @@ -18,8 +18,8 @@ abbrev Function.comp {α : Sort u} {β : Sort v} {δ : Sort w} (f : β → δ) ( abbrev Function.const {α : Sort u} (β : Sort v) (a : α) : β → α := fun x => a -@[reducible] def inferInstance {α : Type u} [i : α] : α := i -@[reducible] def inferInstanceAs (α : Type u) [i : α] : α := i +@[reducible] def inferInstance {α : Sort u} [i : α] : α := i +@[reducible] def inferInstanceAs (α : Sort u) [i : α] : α := i set_option bootstrap.inductiveCheckResultingUniverse false in inductive PUnit : Sort u where @@ -61,6 +61,8 @@ abbrev Eq.ndrec.{u1, u2} {α : Sort u2} {a : α} {motive : α → Sort u1} (m : @[matchPattern] def rfl {α : Sort u} {a : α} : Eq a a := Eq.refl a +@[simp] theorem id_eq (a : α) : Eq (id a) a := rfl + theorem Eq.subst {α : Sort u} {motive : α → Prop} {a b : α} (h₁ : Eq a b) (h₂ : motive a) : motive b := Eq.ndrec h₂ h₁ @@ -1183,12 +1185,12 @@ instance (m) : MonadLiftT m m where but not restricted to monad transformers. Alternatively, an implementation of [MonadTransFunctor](http://duairc.netsoc.ie/layers-docs/Control-Monad-Layer.html#t:MonadTransFunctor). -/ class MonadFunctor (m : Type u → Type v) (n : Type u → Type w) where - monadMap {α : Type u} : (∀ {β}, m β → m β) → n α → n α + monadMap {α : Type u} : ({β : Type u} → m β → m β) → n α → n α /-- The reflexive-transitive closure of `MonadFunctor`. `monadMap` is used to transitively lift Monad morphisms -/ class MonadFunctorT (m : Type u → Type v) (n : Type u → Type w) where - monadMap {α : Type u} : (∀ {β}, m β → m β) → n α → n α + monadMap {α : Type u} : ({β : Type u} → m β → m β) → n α → n α export MonadFunctorT (monadMap) @@ -1302,7 +1304,7 @@ end ReaderT Note: This class can be seen as a simplification of the more "principled" definition ``` class MonadReader (ρ : outParam (Type u)) (n : Type u → Type u) where - lift {α : Type u} : (∀ {m : Type u → Type u} [Monad m], ReaderT ρ m α) → n α + lift {α : Type u} : ({m : Type u → Type u} → [Monad m] → ReaderT ρ m α) → n α ``` -/ class MonadReaderOf (ρ : Type u) (m : Type u → Type v) where diff --git a/stage0/src/Lean/Util/ReplaceExpr.lean b/stage0/src/Lean/Util/ReplaceExpr.lean index 2b708ba758..b229f31032 100644 --- a/stage0/src/Lean/Util/ReplaceExpr.lean +++ b/stage0/src/Lean/Util/ReplaceExpr.lean @@ -19,7 +19,7 @@ structure State where abbrev ReplaceM := StateM State @[inline] unsafe def cache (i : USize) (key : Expr) (result : Expr) : ReplaceM Expr := do - modify fun s => { keys := s.keys.uset i key lcProof, results := s.results.uset i result lcProof }; + modify fun ⟨keys, results⟩ => { keys := keys.uset i key lcProof, results := results.uset i result lcProof }; pure result @[inline] unsafe def replaceUnsafeM (f? : Expr → Option Expr) (size : USize) (e : Expr) : ReplaceM Expr := do diff --git a/stage0/stdlib/CMakeLists.txt b/stage0/stdlib/CMakeLists.txt index a8791f0c8c..74044b2083 100644 --- a/stage0/stdlib/CMakeLists.txt +++ b/stage0/stdlib/CMakeLists.txt @@ -1 +1 @@ -add_library (stage0 OBJECT ./Init.c ./Init/Classical.c ./Init/Coe.c ./Init/Control.c ./Init/Control/Basic.c ./Init/Control/EState.c ./Init/Control/Except.c ./Init/Control/Id.c ./Init/Control/Lawful.c ./Init/Control/Option.c ./Init/Control/Reader.c ./Init/Control/State.c ./Init/Control/StateRef.c ./Init/Core.c ./Init/Data.c ./Init/Data/Array.c ./Init/Data/Array/Basic.c ./Init/Data/Array/BinSearch.c ./Init/Data/Array/InsertionSort.c ./Init/Data/Array/QSort.c ./Init/Data/Array/Subarray.c ./Init/Data/Basic.c ./Init/Data/ByteArray.c ./Init/Data/ByteArray/Basic.c ./Init/Data/Char.c ./Init/Data/Char/Basic.c ./Init/Data/Fin.c ./Init/Data/Fin/Basic.c ./Init/Data/Float.c ./Init/Data/FloatArray.c ./Init/Data/FloatArray/Basic.c ./Init/Data/Format.c ./Init/Data/Format/Basic.c ./Init/Data/Format/Instances.c ./Init/Data/Format/Macro.c ./Init/Data/Hashable.c ./Init/Data/Int.c ./Init/Data/Int/Basic.c ./Init/Data/List.c ./Init/Data/List/Basic.c ./Init/Data/List/BasicAux.c ./Init/Data/List/Control.c ./Init/Data/Nat.c ./Init/Data/Nat/Basic.c ./Init/Data/Nat/Bitwise.c ./Init/Data/Nat/Control.c ./Init/Data/Nat/Div.c ./Init/Data/OfScientific.c ./Init/Data/Option.c ./Init/Data/Option/Basic.c ./Init/Data/Option/BasicAux.c ./Init/Data/Option/Instances.c ./Init/Data/Random.c ./Init/Data/Range.c ./Init/Data/Repr.c ./Init/Data/Stream.c ./Init/Data/String.c ./Init/Data/String/Basic.c ./Init/Data/String/Extra.c ./Init/Data/ToString.c ./Init/Data/ToString/Basic.c ./Init/Data/ToString/Macro.c ./Init/Data/UInt.c ./Init/Fix.c ./Init/Hints.c ./Init/Meta.c ./Init/Notation.c ./Init/NotationExtra.c ./Init/Prelude.c ./Init/SimpLemmas.c ./Init/SizeOf.c ./Init/System.c ./Init/System/FilePath.c ./Init/System/IO.c ./Init/System/IOError.c ./Init/System/Platform.c ./Init/System/ST.c ./Init/Util.c ./Init/WF.c ./Lean.c ./Lean/Attributes.c ./Lean/AuxRecursor.c ./Lean/Class.c ./Lean/Compiler.c ./Lean/Compiler/BorrowedAnnotation.c ./Lean/Compiler/ClosedTermCache.c ./Lean/Compiler/ConstFolding.c ./Lean/Compiler/ExportAttr.c ./Lean/Compiler/ExternAttr.c ./Lean/Compiler/IR.c ./Lean/Compiler/IR/Basic.c ./Lean/Compiler/IR/Borrow.c ./Lean/Compiler/IR/Boxing.c ./Lean/Compiler/IR/Checker.c ./Lean/Compiler/IR/CompilerM.c ./Lean/Compiler/IR/CtorLayout.c ./Lean/Compiler/IR/ElimDeadBranches.c ./Lean/Compiler/IR/ElimDeadVars.c ./Lean/Compiler/IR/EmitC.c ./Lean/Compiler/IR/EmitUtil.c ./Lean/Compiler/IR/ExpandResetReuse.c ./Lean/Compiler/IR/Format.c ./Lean/Compiler/IR/FreeVars.c ./Lean/Compiler/IR/LiveVars.c ./Lean/Compiler/IR/NormIds.c ./Lean/Compiler/IR/PushProj.c ./Lean/Compiler/IR/RC.c ./Lean/Compiler/IR/ResetReuse.c ./Lean/Compiler/IR/SimpCase.c ./Lean/Compiler/IR/Sorry.c ./Lean/Compiler/IR/UnboxResult.c ./Lean/Compiler/ImplementedByAttr.c ./Lean/Compiler/InitAttr.c ./Lean/Compiler/InlineAttrs.c ./Lean/Compiler/NameMangling.c ./Lean/Compiler/NeverExtractAttr.c ./Lean/Compiler/Specialize.c ./Lean/Compiler/Util.c ./Lean/CoreM.c ./Lean/Data.c ./Lean/Data/Format.c ./Lean/Data/Json.c ./Lean/Data/Json/Basic.c ./Lean/Data/Json/FromToJson.c ./Lean/Data/Json/Parser.c ./Lean/Data/Json/Printer.c ./Lean/Data/Json/Stream.c ./Lean/Data/JsonRpc.c ./Lean/Data/KVMap.c ./Lean/Data/LBool.c ./Lean/Data/LOption.c ./Lean/Data/Lsp.c ./Lean/Data/Lsp/Basic.c ./Lean/Data/Lsp/Capabilities.c ./Lean/Data/Lsp/Communication.c ./Lean/Data/Lsp/Diagnostics.c ./Lean/Data/Lsp/Extra.c ./Lean/Data/Lsp/InitShutdown.c ./Lean/Data/Lsp/Ipc.c ./Lean/Data/Lsp/LanguageFeatures.c ./Lean/Data/Lsp/TextSync.c ./Lean/Data/Lsp/Utf16.c ./Lean/Data/Lsp/Workspace.c ./Lean/Data/Name.c ./Lean/Data/NameTrie.c ./Lean/Data/Occurrences.c ./Lean/Data/OpenDecl.c ./Lean/Data/Options.c ./Lean/Data/Position.c ./Lean/Data/PrefixTree.c ./Lean/Data/SMap.c ./Lean/Data/Trie.c ./Lean/Declaration.c ./Lean/DeclarationRange.c ./Lean/DocString.c ./Lean/Elab.c ./Lean/Elab/App.c ./Lean/Elab/Attributes.c ./Lean/Elab/AutoBound.c ./Lean/Elab/Binders.c ./Lean/Elab/BuiltinNotation.c ./Lean/Elab/CollectFVars.c ./Lean/Elab/Command.c ./Lean/Elab/DeclModifiers.c ./Lean/Elab/DeclUtil.c ./Lean/Elab/Declaration.c ./Lean/Elab/DeclarationRange.c ./Lean/Elab/DefView.c ./Lean/Elab/Deriving.c ./Lean/Elab/Deriving/BEq.c ./Lean/Elab/Deriving/Basic.c ./Lean/Elab/Deriving/DecEq.c ./Lean/Elab/Deriving/FromToJson.c ./Lean/Elab/Deriving/Inhabited.c ./Lean/Elab/Deriving/Repr.c ./Lean/Elab/Deriving/SizeOf.c ./Lean/Elab/Deriving/Util.c ./Lean/Elab/Do.c ./Lean/Elab/Exception.c ./Lean/Elab/Extra.c ./Lean/Elab/Frontend.c ./Lean/Elab/Import.c ./Lean/Elab/Inductive.c ./Lean/Elab/InfoTree.c ./Lean/Elab/LetRec.c ./Lean/Elab/Level.c ./Lean/Elab/Log.c ./Lean/Elab/Match.c ./Lean/Elab/MutualDef.c ./Lean/Elab/PreDefinition.c ./Lean/Elab/PreDefinition/Basic.c ./Lean/Elab/PreDefinition/Main.c ./Lean/Elab/PreDefinition/MkInhabitant.c ./Lean/Elab/PreDefinition/Structural.c ./Lean/Elab/PreDefinition/WF.c ./Lean/Elab/Print.c ./Lean/Elab/Quotation.c ./Lean/Elab/Quotation/Util.c ./Lean/Elab/StructInst.c ./Lean/Elab/Structure.c ./Lean/Elab/Syntax.c ./Lean/Elab/SyntheticMVars.c ./Lean/Elab/Tactic.c ./Lean/Elab/Tactic/Basic.c ./Lean/Elab/Tactic/Binders.c ./Lean/Elab/Tactic/ElabTerm.c ./Lean/Elab/Tactic/Generalize.c ./Lean/Elab/Tactic/Induction.c ./Lean/Elab/Tactic/Injection.c ./Lean/Elab/Tactic/Location.c ./Lean/Elab/Tactic/Match.c ./Lean/Elab/Tactic/Rewrite.c ./Lean/Elab/Tactic/Simp.c ./Lean/Elab/Term.c ./Lean/Elab/Util.c ./Lean/Environment.c ./Lean/Eval.c ./Lean/Exception.c ./Lean/Expr.c ./Lean/HeadIndex.c ./Lean/Hygiene.c ./Lean/InternalExceptionId.c ./Lean/KeyedDeclsAttribute.c ./Lean/Level.c ./Lean/LocalContext.c ./Lean/Message.c ./Lean/Meta.c ./Lean/Meta/AbstractMVars.c ./Lean/Meta/AbstractNestedProofs.c ./Lean/Meta/AppBuilder.c ./Lean/Meta/Basic.c ./Lean/Meta/Check.c ./Lean/Meta/Closure.c ./Lean/Meta/Coe.c ./Lean/Meta/CollectMVars.c ./Lean/Meta/DiscrTree.c ./Lean/Meta/DiscrTreeTypes.c ./Lean/Meta/ExprDefEq.c ./Lean/Meta/ForEachExpr.c ./Lean/Meta/FunInfo.c ./Lean/Meta/GeneralizeTelescope.c ./Lean/Meta/GetConst.c ./Lean/Meta/Inductive.c ./Lean/Meta/InferType.c ./Lean/Meta/Instances.c ./Lean/Meta/KAbstract.c ./Lean/Meta/LevelDefEq.c ./Lean/Meta/Match.c ./Lean/Meta/Match/Basic.c ./Lean/Meta/Match/CaseArraySizes.c ./Lean/Meta/Match/CaseValues.c ./Lean/Meta/Match/MVarRenaming.c ./Lean/Meta/Match/Match.c ./Lean/Meta/Match/MatchPatternAttr.c ./Lean/Meta/Match/MatcherInfo.c ./Lean/Meta/MatchUtil.c ./Lean/Meta/Offset.c ./Lean/Meta/PPGoal.c ./Lean/Meta/RecursorInfo.c ./Lean/Meta/Reduce.c ./Lean/Meta/ReduceEval.c ./Lean/Meta/SizeOf.c ./Lean/Meta/SynthInstance.c ./Lean/Meta/Tactic.c ./Lean/Meta/Tactic/Apply.c ./Lean/Meta/Tactic/Assert.c ./Lean/Meta/Tactic/Assumption.c ./Lean/Meta/Tactic/Cases.c ./Lean/Meta/Tactic/Clear.c ./Lean/Meta/Tactic/Constructor.c ./Lean/Meta/Tactic/Delta.c ./Lean/Meta/Tactic/ElimInfo.c ./Lean/Meta/Tactic/FVarSubst.c ./Lean/Meta/Tactic/Generalize.c ./Lean/Meta/Tactic/Induction.c ./Lean/Meta/Tactic/Injection.c ./Lean/Meta/Tactic/Intro.c ./Lean/Meta/Tactic/Replace.c ./Lean/Meta/Tactic/Revert.c ./Lean/Meta/Tactic/Rewrite.c ./Lean/Meta/Tactic/Simp.c ./Lean/Meta/Tactic/Simp/CongrLemmas.c ./Lean/Meta/Tactic/Simp/Main.c ./Lean/Meta/Tactic/Simp/Rewrite.c ./Lean/Meta/Tactic/Simp/SimpLemmas.c ./Lean/Meta/Tactic/Simp/Types.c ./Lean/Meta/Tactic/Subst.c ./Lean/Meta/Tactic/Util.c ./Lean/Meta/Transform.c ./Lean/Meta/TransparencyMode.c ./Lean/Meta/UnificationHint.c ./Lean/Meta/WHNF.c ./Lean/MetavarContext.c ./Lean/Modifiers.c ./Lean/MonadEnv.c ./Lean/Parser.c ./Lean/Parser/Attr.c ./Lean/Parser/Basic.c ./Lean/Parser/Command.c ./Lean/Parser/Do.c ./Lean/Parser/Extension.c ./Lean/Parser/Extra.c ./Lean/Parser/Level.c ./Lean/Parser/Module.c ./Lean/Parser/StrInterpolation.c ./Lean/Parser/Syntax.c ./Lean/Parser/Tactic.c ./Lean/Parser/Term.c ./Lean/ParserCompiler.c ./Lean/ParserCompiler/Attribute.c ./Lean/PrettyPrinter.c ./Lean/PrettyPrinter/Basic.c ./Lean/PrettyPrinter/Delaborator.c ./Lean/PrettyPrinter/Delaborator/Basic.c ./Lean/PrettyPrinter/Delaborator/Builtins.c ./Lean/PrettyPrinter/Formatter.c ./Lean/PrettyPrinter/Parenthesizer.c ./Lean/ProjFns.c ./Lean/ReducibilityAttrs.c ./Lean/ResolveName.c ./Lean/Runtime.c ./Lean/ScopedEnvExtension.c ./Lean/Server.c ./Lean/Server/AsyncList.c ./Lean/Server/FileSource.c ./Lean/Server/FileWorker.c ./Lean/Server/InfoUtils.c ./Lean/Server/Snapshots.c ./Lean/Server/Utils.c ./Lean/Server/Watchdog.c ./Lean/Structure.c ./Lean/Syntax.c ./Lean/ToExpr.c ./Lean/Util.c ./Lean/Util/CollectFVars.c ./Lean/Util/CollectLevelParams.c ./Lean/Util/CollectMVars.c ./Lean/Util/Constructions.c ./Lean/Util/FindExpr.c ./Lean/Util/FindMVar.c ./Lean/Util/FoldConsts.c ./Lean/Util/ForEachExpr.c ./Lean/Util/MonadCache.c ./Lean/Util/OccursCheck.c ./Lean/Util/PPExt.c ./Lean/Util/Path.c ./Lean/Util/Profile.c ./Lean/Util/RecDepth.c ./Lean/Util/Recognizers.c ./Lean/Util/ReplaceExpr.c ./Lean/Util/ReplaceLevel.c ./Lean/Util/SCC.c ./Lean/Util/Sorry.c ./Lean/Util/Trace.c ./Leanpkg.c ./Leanpkg/Git.c ./Leanpkg/LeanVersion.c ./Leanpkg/Manifest.c ./Leanpkg/Proc.c ./Leanpkg/Resolve.c ./Leanpkg/Toml.c ./Std.c ./Std/Control/Lawful.c ./Std/Data.c ./Std/Data/AssocList.c ./Std/Data/BinomialHeap.c ./Std/Data/DList.c ./Std/Data/HashMap.c ./Std/Data/HashSet.c ./Std/Data/PersistentArray.c ./Std/Data/PersistentHashMap.c ./Std/Data/PersistentHashSet.c ./Std/Data/Queue.c ./Std/Data/RBMap.c ./Std/Data/RBTree.c ./Std/Data/Stack.c ./Std/ShareCommon.c ) +add_library (stage0 OBJECT ./Init.c ./Init/Classical.c ./Init/Coe.c ./Init/Control.c ./Init/Control/Basic.c ./Init/Control/EState.c ./Init/Control/Except.c ./Init/Control/Id.c ./Init/Control/Lawful.c ./Init/Control/Option.c ./Init/Control/Reader.c ./Init/Control/State.c ./Init/Control/StateRef.c ./Init/Core.c ./Init/Data.c ./Init/Data/Array.c ./Init/Data/Array/Basic.c ./Init/Data/Array/BinSearch.c ./Init/Data/Array/InsertionSort.c ./Init/Data/Array/QSort.c ./Init/Data/Array/Subarray.c ./Init/Data/Basic.c ./Init/Data/ByteArray.c ./Init/Data/ByteArray/Basic.c ./Init/Data/Char.c ./Init/Data/Char/Basic.c ./Init/Data/Fin.c ./Init/Data/Fin/Basic.c ./Init/Data/Float.c ./Init/Data/FloatArray.c ./Init/Data/FloatArray/Basic.c ./Init/Data/Format.c ./Init/Data/Format/Basic.c ./Init/Data/Format/Instances.c ./Init/Data/Format/Macro.c ./Init/Data/Hashable.c ./Init/Data/Int.c ./Init/Data/Int/Basic.c ./Init/Data/List.c ./Init/Data/List/Basic.c ./Init/Data/List/BasicAux.c ./Init/Data/List/Control.c ./Init/Data/Nat.c ./Init/Data/Nat/Basic.c ./Init/Data/Nat/Bitwise.c ./Init/Data/Nat/Control.c ./Init/Data/Nat/Div.c ./Init/Data/OfScientific.c ./Init/Data/Option.c ./Init/Data/Option/Basic.c ./Init/Data/Option/BasicAux.c ./Init/Data/Option/Instances.c ./Init/Data/Random.c ./Init/Data/Range.c ./Init/Data/Repr.c ./Init/Data/Stream.c ./Init/Data/String.c ./Init/Data/String/Basic.c ./Init/Data/String/Extra.c ./Init/Data/ToString.c ./Init/Data/ToString/Basic.c ./Init/Data/ToString/Macro.c ./Init/Data/UInt.c ./Init/Fix.c ./Init/Hints.c ./Init/Meta.c ./Init/Notation.c ./Init/NotationExtra.c ./Init/Prelude.c ./Init/SimpLemmas.c ./Init/SizeOf.c ./Init/System.c ./Init/System/FilePath.c ./Init/System/IO.c ./Init/System/IOError.c ./Init/System/Platform.c ./Init/System/ST.c ./Init/Util.c ./Init/WF.c ./Lean.c ./Lean/Attributes.c ./Lean/AuxRecursor.c ./Lean/Class.c ./Lean/Compiler.c ./Lean/Compiler/BorrowedAnnotation.c ./Lean/Compiler/ClosedTermCache.c ./Lean/Compiler/ConstFolding.c ./Lean/Compiler/ExportAttr.c ./Lean/Compiler/ExternAttr.c ./Lean/Compiler/IR.c ./Lean/Compiler/IR/Basic.c ./Lean/Compiler/IR/Borrow.c ./Lean/Compiler/IR/Boxing.c ./Lean/Compiler/IR/Checker.c ./Lean/Compiler/IR/CompilerM.c ./Lean/Compiler/IR/CtorLayout.c ./Lean/Compiler/IR/ElimDeadBranches.c ./Lean/Compiler/IR/ElimDeadVars.c ./Lean/Compiler/IR/EmitC.c ./Lean/Compiler/IR/EmitUtil.c ./Lean/Compiler/IR/ExpandResetReuse.c ./Lean/Compiler/IR/Format.c ./Lean/Compiler/IR/FreeVars.c ./Lean/Compiler/IR/LiveVars.c ./Lean/Compiler/IR/NormIds.c ./Lean/Compiler/IR/PushProj.c ./Lean/Compiler/IR/RC.c ./Lean/Compiler/IR/ResetReuse.c ./Lean/Compiler/IR/SimpCase.c ./Lean/Compiler/IR/Sorry.c ./Lean/Compiler/IR/UnboxResult.c ./Lean/Compiler/ImplementedByAttr.c ./Lean/Compiler/InitAttr.c ./Lean/Compiler/InlineAttrs.c ./Lean/Compiler/NameMangling.c ./Lean/Compiler/NeverExtractAttr.c ./Lean/Compiler/Specialize.c ./Lean/Compiler/Util.c ./Lean/CoreM.c ./Lean/Data.c ./Lean/Data/Format.c ./Lean/Data/Json.c ./Lean/Data/Json/Basic.c ./Lean/Data/Json/FromToJson.c ./Lean/Data/Json/Parser.c ./Lean/Data/Json/Printer.c ./Lean/Data/Json/Stream.c ./Lean/Data/JsonRpc.c ./Lean/Data/KVMap.c ./Lean/Data/LBool.c ./Lean/Data/LOption.c ./Lean/Data/Lsp.c ./Lean/Data/Lsp/Basic.c ./Lean/Data/Lsp/Capabilities.c ./Lean/Data/Lsp/Communication.c ./Lean/Data/Lsp/Diagnostics.c ./Lean/Data/Lsp/Extra.c ./Lean/Data/Lsp/InitShutdown.c ./Lean/Data/Lsp/Ipc.c ./Lean/Data/Lsp/LanguageFeatures.c ./Lean/Data/Lsp/TextSync.c ./Lean/Data/Lsp/Utf16.c ./Lean/Data/Lsp/Workspace.c ./Lean/Data/Name.c ./Lean/Data/NameTrie.c ./Lean/Data/Occurrences.c ./Lean/Data/OpenDecl.c ./Lean/Data/Options.c ./Lean/Data/Position.c ./Lean/Data/PrefixTree.c ./Lean/Data/SMap.c ./Lean/Data/Trie.c ./Lean/Declaration.c ./Lean/DeclarationRange.c ./Lean/DocString.c ./Lean/Elab.c ./Lean/Elab/App.c ./Lean/Elab/Attributes.c ./Lean/Elab/AutoBound.c ./Lean/Elab/Binders.c ./Lean/Elab/BuiltinNotation.c ./Lean/Elab/CollectFVars.c ./Lean/Elab/Command.c ./Lean/Elab/DeclModifiers.c ./Lean/Elab/DeclUtil.c ./Lean/Elab/Declaration.c ./Lean/Elab/DeclarationRange.c ./Lean/Elab/DefView.c ./Lean/Elab/Deriving.c ./Lean/Elab/Deriving/BEq.c ./Lean/Elab/Deriving/Basic.c ./Lean/Elab/Deriving/DecEq.c ./Lean/Elab/Deriving/FromToJson.c ./Lean/Elab/Deriving/Inhabited.c ./Lean/Elab/Deriving/Repr.c ./Lean/Elab/Deriving/SizeOf.c ./Lean/Elab/Deriving/Util.c ./Lean/Elab/Do.c ./Lean/Elab/Exception.c ./Lean/Elab/Extra.c ./Lean/Elab/Frontend.c ./Lean/Elab/Import.c ./Lean/Elab/Inductive.c ./Lean/Elab/InfoTree.c ./Lean/Elab/LetRec.c ./Lean/Elab/Level.c ./Lean/Elab/Log.c ./Lean/Elab/Match.c ./Lean/Elab/MutualDef.c ./Lean/Elab/PreDefinition.c ./Lean/Elab/PreDefinition/Basic.c ./Lean/Elab/PreDefinition/Main.c ./Lean/Elab/PreDefinition/MkInhabitant.c ./Lean/Elab/PreDefinition/Structural.c ./Lean/Elab/PreDefinition/WF.c ./Lean/Elab/Print.c ./Lean/Elab/Quotation.c ./Lean/Elab/Quotation/Util.c ./Lean/Elab/StructInst.c ./Lean/Elab/Structure.c ./Lean/Elab/Syntax.c ./Lean/Elab/SyntheticMVars.c ./Lean/Elab/Tactic.c ./Lean/Elab/Tactic/Basic.c ./Lean/Elab/Tactic/Binders.c ./Lean/Elab/Tactic/ElabTerm.c ./Lean/Elab/Tactic/Generalize.c ./Lean/Elab/Tactic/Induction.c ./Lean/Elab/Tactic/Injection.c ./Lean/Elab/Tactic/Location.c ./Lean/Elab/Tactic/Match.c ./Lean/Elab/Tactic/Rewrite.c ./Lean/Elab/Tactic/Simp.c ./Lean/Elab/Term.c ./Lean/Elab/Util.c ./Lean/Environment.c ./Lean/Eval.c ./Lean/Exception.c ./Lean/Expr.c ./Lean/HeadIndex.c ./Lean/Hygiene.c ./Lean/InternalExceptionId.c ./Lean/KeyedDeclsAttribute.c ./Lean/Level.c ./Lean/LocalContext.c ./Lean/Message.c ./Lean/Meta.c ./Lean/Meta/AbstractMVars.c ./Lean/Meta/AbstractNestedProofs.c ./Lean/Meta/AppBuilder.c ./Lean/Meta/Basic.c ./Lean/Meta/Check.c ./Lean/Meta/Closure.c ./Lean/Meta/Coe.c ./Lean/Meta/CollectMVars.c ./Lean/Meta/DiscrTree.c ./Lean/Meta/DiscrTreeTypes.c ./Lean/Meta/ExprDefEq.c ./Lean/Meta/ForEachExpr.c ./Lean/Meta/FunInfo.c ./Lean/Meta/GeneralizeTelescope.c ./Lean/Meta/GetConst.c ./Lean/Meta/Inductive.c ./Lean/Meta/InferType.c ./Lean/Meta/Instances.c ./Lean/Meta/KAbstract.c ./Lean/Meta/LevelDefEq.c ./Lean/Meta/Match.c ./Lean/Meta/Match/Basic.c ./Lean/Meta/Match/CaseArraySizes.c ./Lean/Meta/Match/CaseValues.c ./Lean/Meta/Match/MVarRenaming.c ./Lean/Meta/Match/Match.c ./Lean/Meta/Match/MatchPatternAttr.c ./Lean/Meta/Match/MatcherInfo.c ./Lean/Meta/MatchUtil.c ./Lean/Meta/Offset.c ./Lean/Meta/PPGoal.c ./Lean/Meta/RecursorInfo.c ./Lean/Meta/Reduce.c ./Lean/Meta/ReduceEval.c ./Lean/Meta/SizeOf.c ./Lean/Meta/SynthInstance.c ./Lean/Meta/Tactic.c ./Lean/Meta/Tactic/Apply.c ./Lean/Meta/Tactic/Assert.c ./Lean/Meta/Tactic/Assumption.c ./Lean/Meta/Tactic/Cases.c ./Lean/Meta/Tactic/Clear.c ./Lean/Meta/Tactic/Constructor.c ./Lean/Meta/Tactic/Delta.c ./Lean/Meta/Tactic/ElimInfo.c ./Lean/Meta/Tactic/FVarSubst.c ./Lean/Meta/Tactic/Generalize.c ./Lean/Meta/Tactic/Induction.c ./Lean/Meta/Tactic/Injection.c ./Lean/Meta/Tactic/Intro.c ./Lean/Meta/Tactic/Replace.c ./Lean/Meta/Tactic/Revert.c ./Lean/Meta/Tactic/Rewrite.c ./Lean/Meta/Tactic/Simp.c ./Lean/Meta/Tactic/Simp/CongrLemmas.c ./Lean/Meta/Tactic/Simp/Main.c ./Lean/Meta/Tactic/Simp/Rewrite.c ./Lean/Meta/Tactic/Simp/SimpLemmas.c ./Lean/Meta/Tactic/Simp/Types.c ./Lean/Meta/Tactic/Subst.c ./Lean/Meta/Tactic/Util.c ./Lean/Meta/Transform.c ./Lean/Meta/TransparencyMode.c ./Lean/Meta/UnificationHint.c ./Lean/Meta/WHNF.c ./Lean/MetavarContext.c ./Lean/Modifiers.c ./Lean/MonadEnv.c ./Lean/Parser.c ./Lean/Parser/Attr.c ./Lean/Parser/Basic.c ./Lean/Parser/Command.c ./Lean/Parser/Do.c ./Lean/Parser/Extension.c ./Lean/Parser/Extra.c ./Lean/Parser/Level.c ./Lean/Parser/Module.c ./Lean/Parser/StrInterpolation.c ./Lean/Parser/Syntax.c ./Lean/Parser/Tactic.c ./Lean/Parser/Term.c ./Lean/ParserCompiler.c ./Lean/ParserCompiler/Attribute.c ./Lean/PrettyPrinter.c ./Lean/PrettyPrinter/Basic.c ./Lean/PrettyPrinter/Delaborator.c ./Lean/PrettyPrinter/Delaborator/Basic.c ./Lean/PrettyPrinter/Delaborator/Builtins.c ./Lean/PrettyPrinter/Formatter.c ./Lean/PrettyPrinter/Parenthesizer.c ./Lean/ProjFns.c ./Lean/ReducibilityAttrs.c ./Lean/ResolveName.c ./Lean/Runtime.c ./Lean/ScopedEnvExtension.c ./Lean/Server.c ./Lean/Server/AsyncList.c ./Lean/Server/FileSource.c ./Lean/Server/FileWorker.c ./Lean/Server/InfoUtils.c ./Lean/Server/Snapshots.c ./Lean/Server/Utils.c ./Lean/Server/Watchdog.c ./Lean/Structure.c ./Lean/Syntax.c ./Lean/ToExpr.c ./Lean/Util.c ./Lean/Util/CollectFVars.c ./Lean/Util/CollectLevelParams.c ./Lean/Util/CollectMVars.c ./Lean/Util/Constructions.c ./Lean/Util/FindExpr.c ./Lean/Util/FindMVar.c ./Lean/Util/FoldConsts.c ./Lean/Util/ForEachExpr.c ./Lean/Util/MonadCache.c ./Lean/Util/OccursCheck.c ./Lean/Util/PPExt.c ./Lean/Util/Path.c ./Lean/Util/Profile.c ./Lean/Util/RecDepth.c ./Lean/Util/Recognizers.c ./Lean/Util/ReplaceExpr.c ./Lean/Util/ReplaceLevel.c ./Lean/Util/SCC.c ./Lean/Util/Sorry.c ./Lean/Util/Trace.c ./Leanpkg.c ./Leanpkg/Git.c ./Leanpkg/LeanVersion.c ./Leanpkg/Manifest.c ./Leanpkg/Proc.c ./Leanpkg/Resolve.c ./Leanpkg/Toml.c ./Std.c ./Std/Data.c ./Std/Data/AssocList.c ./Std/Data/BinomialHeap.c ./Std/Data/DList.c ./Std/Data/HashMap.c ./Std/Data/HashSet.c ./Std/Data/PersistentArray.c ./Std/Data/PersistentHashMap.c ./Std/Data/PersistentHashSet.c ./Std/Data/Queue.c ./Std/Data/RBMap.c ./Std/Data/RBTree.c ./Std/Data/Stack.c ./Std/ShareCommon.c ) diff --git a/stage0/stdlib/Init/Control/Except.c b/stage0/stdlib/Init/Control/Except.c index a9c5e0a43c..7e49c64cad 100644 --- a/stage0/stdlib/Init/Control/Except.c +++ b/stage0/stdlib/Init/Control/Except.c @@ -55,7 +55,6 @@ lean_object* l_instMonadExceptOfExceptT__1___rarg___lambda__1(lean_object*, lean lean_object* l_ExceptT_instMonadLiftExceptT(lean_object*, lean_object*); lean_object* l_ExceptT_bindCont___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_ExceptT_instMonadExceptT___rarg(lean_object*); -lean_object* l_Except_tryCatch_match__1(lean_object*, lean_object*, lean_object*); lean_object* l_Except_map___rarg(lean_object*, lean_object*); lean_object* l_tryFinally(lean_object*, lean_object*, lean_object*); lean_object* l_ExceptT_instMonadExceptT___rarg___lambda__1(lean_object*, lean_object*, lean_object*); @@ -69,6 +68,7 @@ lean_object* l_Except_mapError___rarg(lean_object*, lean_object*); lean_object* l_Except_toBool(lean_object*, lean_object*); lean_object* l_ExceptT_instMonadFunctorExceptT(lean_object*, lean_object*, lean_object*); lean_object* l_Except_instMonadExcept___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_ExceptT_bindCont_match__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Except_map(lean_object*, lean_object*, lean_object*); lean_object* l_instMonadExceptOfExceptT(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Except_instMonadExcept___closed__10; @@ -116,7 +116,6 @@ lean_object* l_instMonadExceptOfExcept___lambda__1(lean_object*, lean_object*); lean_object* l_ExceptT_instMonadLiftExceptExceptT___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_ExceptT_bindCont___at_ExceptT_instMonadExceptT___spec__1(lean_object*, lean_object*); lean_object* l_ExceptT_tryCatch(lean_object*, lean_object*); -lean_object* l_Except_tryCatch_match__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_ExceptT_finally_match__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Except_instMonadExcept___closed__5; lean_object* l_ExceptT_mk(lean_object*, lean_object*, lean_object*); @@ -131,6 +130,7 @@ lean_object* l_ExceptT_bindCont___at_ExceptT_instMonadExceptT___spec__2(lean_obj lean_object* l_ExceptT_run___rarg___boxed(lean_object*); lean_object* l_Except_toOption(lean_object*, lean_object*); lean_object* l_MonadExcept_orelse_x27___rarg___lambda__1(lean_object*, uint8_t, lean_object*, lean_object*); +lean_object* l_ExceptT_bindCont_match__1(lean_object*, lean_object*, lean_object*); lean_object* l_Except_instMonadExcept___closed__9; lean_object* l_ExceptT_run___rarg(lean_object*); lean_object* l_Except_instMonadExcept___closed__1; @@ -458,39 +458,6 @@ lean_dec(x_1); return x_2; } } -lean_object* l_Except_tryCatch_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_ctor_get(x_1, 0); -lean_inc(x_4); -lean_dec(x_1); -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_Except_tryCatch_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_Except_tryCatch_match__1___rarg), 3, 0); -return x_4; -} -} lean_object* l_Except_tryCatch___rarg(lean_object* x_1, lean_object* x_2) { _start: { @@ -949,6 +916,39 @@ x_3 = lean_alloc_closure((void*)(l_ExceptT_pure___rarg), 3, 0); return x_3; } } +lean_object* l_ExceptT_bindCont_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_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +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_ExceptT_bindCont_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_ExceptT_bindCont_match__1___rarg), 3, 0); +return x_4; +} +} lean_object* l_ExceptT_bindCont___rarg(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { diff --git a/stage0/stdlib/Init/Control/Lawful.c b/stage0/stdlib/Init/Control/Lawful.c index 4790d483fb..edfc02b70e 100644 --- a/stage0/stdlib/Init/Control/Lawful.c +++ b/stage0/stdlib/Init/Control/Lawful.c @@ -1,6 +1,6 @@ // Lean compiler output // Module: Init.Control.Lawful -// Imports: Init.SimpLemmas +// Imports: Init.SimpLemmas Init.Control.Except Init.Control.StateRef #include #if defined(__clang__) #pragma clang diagnostic ignored "-Wunused-parameter" @@ -13,7 +13,44 @@ #ifdef __cplusplus extern "C" { #endif +lean_object* l_ExceptT_run__bind_match__1(lean_object*, lean_object*, lean_object*); +lean_object* l_ExceptT_run__bind_match__1___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_ExceptT_run__bind_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_ctor_get(x_1, 0); +lean_inc(x_4); +lean_dec(x_1); +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_ExceptT_run__bind_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_ExceptT_run__bind_match__1___rarg), 3, 0); +return x_4; +} +} lean_object* initialize_Init_SimpLemmas(lean_object*); +lean_object* initialize_Init_Control_Except(lean_object*); +lean_object* initialize_Init_Control_StateRef(lean_object*); static bool _G_initialized = false; lean_object* initialize_Init_Control_Lawful(lean_object* w) { lean_object * res; @@ -22,6 +59,12 @@ _G_initialized = true; res = initialize_Init_SimpLemmas(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); +res = initialize_Init_Control_Except(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); +res = initialize_Init_Control_StateRef(lean_io_mk_world()); +if (lean_io_result_is_error(res)) return res; +lean_dec_ref(res); return lean_io_result_mk_ok(lean_box(0)); } #ifdef __cplusplus diff --git a/stage0/stdlib/Lean/Elab/Inductive.c b/stage0/stdlib/Lean/Elab/Inductive.c index 4f150069c5..006b4b99de 100644 --- a/stage0/stdlib/Lean/Elab/Inductive.c +++ b/stage0/stdlib/Lean/Elab/Inductive.c @@ -10491,82 +10491,102 @@ return x_4; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, size_t x_4, lean_object* x_5, lean_object* x_6) { _start: { -size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_235; lean_object* x_236; size_t x_237; uint8_t x_238; +size_t x_7; size_t x_8; lean_object* x_9; lean_object* x_216; lean_object* x_217; size_t x_218; uint8_t x_219; x_7 = lean_ptr_addr(x_5); x_8 = x_4 == 0 ? x_7 : x_7 % x_4; -x_235 = lean_ctor_get(x_6, 0); +x_216 = lean_ctor_get(x_6, 0); +lean_inc(x_216); +x_217 = lean_array_uget(x_216, x_8); +lean_dec(x_216); +x_218 = lean_ptr_addr(x_217); +lean_dec(x_217); +x_219 = x_218 == x_7; +if (x_219 == 0) +{ +uint8_t x_220; +x_220 = l_Lean_Expr_isFVar(x_5); +if (x_220 == 0) +{ +lean_object* x_221; +x_221 = lean_box(0); +x_9 = x_221; +goto block_215; +} +else +{ +lean_object* x_222; +x_222 = l_Std_HashMapImp_find_x3f___at_Lean_MetavarContext_instantiateExprMVars___spec__1(x_2, x_5); +if (lean_obj_tag(x_222) == 0) +{ +lean_object* x_223; +x_223 = lean_box(0); +x_9 = x_223; +goto block_215; +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; uint8_t x_228; +x_224 = lean_ctor_get(x_222, 0); +lean_inc(x_224); +lean_dec(x_222); +x_225 = lean_unsigned_to_nat(0u); +x_226 = l_Array_extract___rarg(x_3, x_225, x_1); +x_227 = l_Lean_mkAppN(x_224, x_226); +lean_dec(x_226); +x_228 = !lean_is_exclusive(x_6); +if (x_228 == 0) +{ +lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; +x_229 = lean_ctor_get(x_6, 0); +x_230 = lean_ctor_get(x_6, 1); +x_231 = lean_array_uset(x_229, x_8, x_5); +lean_inc(x_227); +x_232 = lean_array_uset(x_230, x_8, x_227); +lean_ctor_set(x_6, 1, x_232); +lean_ctor_set(x_6, 0, x_231); +x_233 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_233, 0, x_227); +lean_ctor_set(x_233, 1, x_6); +return x_233; +} +else +{ +lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; +x_234 = lean_ctor_get(x_6, 0); +x_235 = lean_ctor_get(x_6, 1); lean_inc(x_235); -x_236 = lean_array_uget(x_235, x_8); -x_237 = lean_ptr_addr(x_236); -lean_dec(x_236); -x_238 = x_237 == x_7; -if (x_238 == 0) -{ -uint8_t x_239; -x_239 = l_Lean_Expr_isFVar(x_5); -if (x_239 == 0) -{ -lean_object* x_240; -lean_dec(x_235); -x_240 = lean_box(0); -x_9 = x_240; -goto block_234; -} -else -{ -lean_object* x_241; -x_241 = l_Std_HashMapImp_find_x3f___at_Lean_MetavarContext_instantiateExprMVars___spec__1(x_2, x_5); -if (lean_obj_tag(x_241) == 0) -{ -lean_object* x_242; -lean_dec(x_235); -x_242 = lean_box(0); -x_9 = x_242; -goto block_234; -} -else -{ -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_object* x_249; lean_object* x_250; lean_object* x_251; -x_243 = lean_ctor_get(x_241, 0); -lean_inc(x_243); -lean_dec(x_241); -x_244 = lean_unsigned_to_nat(0u); -x_245 = l_Array_extract___rarg(x_3, x_244, x_1); -x_246 = l_Lean_mkAppN(x_243, x_245); -lean_dec(x_245); -x_247 = lean_array_uset(x_235, x_8, x_5); -x_248 = lean_ctor_get(x_6, 1); -lean_inc(x_248); +lean_inc(x_234); lean_dec(x_6); -lean_inc(x_246); -x_249 = lean_array_uset(x_248, x_8, x_246); -x_250 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_250, 0, x_247); -lean_ctor_set(x_250, 1, x_249); -x_251 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_251, 0, x_246); -lean_ctor_set(x_251, 1, x_250); -return x_251; +x_236 = lean_array_uset(x_234, x_8, x_5); +lean_inc(x_227); +x_237 = lean_array_uset(x_235, x_8, x_227); +x_238 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_238, 0, x_236); +lean_ctor_set(x_238, 1, x_237); +x_239 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_239, 0, x_227); +lean_ctor_set(x_239, 1, x_238); +return x_239; +} } } } else { -lean_object* x_252; lean_object* x_253; lean_object* x_254; -lean_dec(x_235); +lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_dec(x_5); lean_dec(x_3); lean_dec(x_1); -x_252 = lean_ctor_get(x_6, 1); -lean_inc(x_252); -x_253 = lean_array_uget(x_252, x_8); -lean_dec(x_252); -x_254 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_254, 0, x_253); -lean_ctor_set(x_254, 1, x_6); -return x_254; +x_240 = lean_ctor_get(x_6, 1); +lean_inc(x_240); +x_241 = lean_array_uget(x_240, x_8); +lean_dec(x_240); +x_242 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_242, 0, x_241); +lean_ctor_set(x_242, 1, x_6); +return x_242; } -block_234: +block_215: { lean_dec(x_9); switch (lean_obj_tag(x_5)) { @@ -10595,712 +10615,629 @@ if (x_17 == 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_16, 0); x_19 = lean_ctor_get(x_16, 1); -x_20 = lean_ctor_get(x_19, 0); -lean_inc(x_20); -lean_inc(x_5); -x_21 = lean_array_uset(x_20, x_8, x_5); -x_22 = !lean_is_exclusive(x_5); +x_20 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_20, 0, x_10); +lean_ctor_set(x_20, 1, x_11); +lean_ctor_set_uint64(x_20, sizeof(void*)*2, x_12); +x_21 = lean_expr_update_app(x_20, x_14, x_18); +x_22 = !lean_is_exclusive(x_19); if (x_22 == 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_5, 1); -lean_dec(x_23); -x_24 = lean_ctor_get(x_5, 0); -lean_dec(x_24); -x_25 = lean_ctor_get(x_19, 1); -lean_inc(x_25); -lean_dec(x_19); -x_26 = lean_expr_update_app(x_5, x_14, x_18); -lean_inc(x_26); -x_27 = lean_array_uset(x_25, x_8, x_26); -x_28 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_28, 0, x_21); -lean_ctor_set(x_28, 1, x_27); -lean_ctor_set(x_16, 1, x_28); -lean_ctor_set(x_16, 0, x_26); +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +x_23 = lean_ctor_get(x_19, 0); +x_24 = lean_ctor_get(x_19, 1); +x_25 = lean_array_uset(x_23, x_8, x_5); +lean_inc(x_21); +x_26 = lean_array_uset(x_24, x_8, x_21); +lean_ctor_set(x_19, 1, x_26); +lean_ctor_set(x_19, 0, x_25); +lean_ctor_set(x_16, 0, x_21); return x_16; } else { -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -lean_dec(x_5); -x_29 = lean_ctor_get(x_19, 1); -lean_inc(x_29); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_27 = lean_ctor_get(x_19, 0); +x_28 = lean_ctor_get(x_19, 1); +lean_inc(x_28); +lean_inc(x_27); lean_dec(x_19); -x_30 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_30, 0, x_10); -lean_ctor_set(x_30, 1, x_11); -lean_ctor_set_uint64(x_30, sizeof(void*)*2, x_12); -x_31 = lean_expr_update_app(x_30, x_14, x_18); -lean_inc(x_31); -x_32 = lean_array_uset(x_29, x_8, x_31); -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_21); -lean_ctor_set(x_33, 1, x_32); -lean_ctor_set(x_16, 1, x_33); -lean_ctor_set(x_16, 0, x_31); +x_29 = lean_array_uset(x_27, x_8, x_5); +lean_inc(x_21); +x_30 = lean_array_uset(x_28, x_8, x_21); +x_31 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +lean_ctor_set(x_16, 1, x_31); +lean_ctor_set(x_16, 0, x_21); return x_16; } } 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_object* x_43; lean_object* x_44; -x_34 = lean_ctor_get(x_16, 0); -x_35 = lean_ctor_get(x_16, 1); -lean_inc(x_35); -lean_inc(x_34); +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_16, 0); +x_33 = lean_ctor_get(x_16, 1); +lean_inc(x_33); +lean_inc(x_32); lean_dec(x_16); -x_36 = lean_ctor_get(x_35, 0); +x_34 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_34, 0, x_10); +lean_ctor_set(x_34, 1, x_11); +lean_ctor_set_uint64(x_34, sizeof(void*)*2, x_12); +x_35 = lean_expr_update_app(x_34, x_14, x_32); +x_36 = lean_ctor_get(x_33, 0); lean_inc(x_36); -lean_inc(x_5); -x_37 = lean_array_uset(x_36, x_8, x_5); -if (lean_is_exclusive(x_5)) { - lean_ctor_release(x_5, 0); - lean_ctor_release(x_5, 1); - x_38 = x_5; +x_37 = lean_ctor_get(x_33, 1); +lean_inc(x_37); +if (lean_is_exclusive(x_33)) { + lean_ctor_release(x_33, 0); + lean_ctor_release(x_33, 1); + x_38 = x_33; } else { - lean_dec_ref(x_5); + lean_dec_ref(x_33); x_38 = lean_box(0); } -x_39 = lean_ctor_get(x_35, 1); -lean_inc(x_39); -lean_dec(x_35); +x_39 = lean_array_uset(x_36, x_8, x_5); +lean_inc(x_35); +x_40 = lean_array_uset(x_37, x_8, x_35); if (lean_is_scalar(x_38)) { - x_40 = lean_alloc_ctor(5, 2, 8); + x_41 = lean_alloc_ctor(0, 2, 0); } else { - x_40 = x_38; + x_41 = x_38; } -lean_ctor_set(x_40, 0, x_10); -lean_ctor_set(x_40, 1, x_11); -lean_ctor_set_uint64(x_40, sizeof(void*)*2, x_12); -x_41 = lean_expr_update_app(x_40, x_14, x_34); -lean_inc(x_41); -x_42 = lean_array_uset(x_39, x_8, x_41); -x_43 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_43, 0, x_37); -lean_ctor_set(x_43, 1, x_42); -x_44 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_44, 0, x_41); -lean_ctor_set(x_44, 1, x_43); -return x_44; +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_40); +x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_42, 0, x_35); +lean_ctor_set(x_42, 1, x_41); +return x_42; } } case 6: { -lean_object* x_45; lean_object* x_46; lean_object* x_47; uint64_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; -x_45 = lean_ctor_get(x_5, 0); +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_object* x_49; lean_object* x_50; uint8_t x_51; +x_43 = lean_ctor_get(x_5, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_5, 1); +lean_inc(x_44); +x_45 = lean_ctor_get(x_5, 2); lean_inc(x_45); -x_46 = lean_ctor_get(x_5, 1); -lean_inc(x_46); -x_47 = lean_ctor_get(x_5, 2); -lean_inc(x_47); -x_48 = lean_ctor_get_uint64(x_5, sizeof(void*)*3); -lean_inc(x_46); +x_46 = lean_ctor_get_uint64(x_5, sizeof(void*)*3); +lean_inc(x_44); lean_inc(x_3); lean_inc(x_1); -x_49 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_46, x_6); -x_50 = lean_ctor_get(x_49, 0); -lean_inc(x_50); -x_51 = lean_ctor_get(x_49, 1); -lean_inc(x_51); -lean_dec(x_49); -lean_inc(x_47); -x_52 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_47, x_51); -x_53 = !lean_is_exclusive(x_52); -if (x_53 == 0) +x_47 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_44, x_6); +x_48 = lean_ctor_get(x_47, 0); +lean_inc(x_48); +x_49 = lean_ctor_get(x_47, 1); +lean_inc(x_49); +lean_dec(x_47); +lean_inc(x_45); +x_50 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_45, x_49); +x_51 = !lean_is_exclusive(x_50); +if (x_51 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; -x_54 = lean_ctor_get(x_52, 0); -x_55 = lean_ctor_get(x_52, 1); -x_56 = lean_ctor_get(x_55, 0); +lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; uint8_t x_57; +x_52 = lean_ctor_get(x_50, 0); +x_53 = lean_ctor_get(x_50, 1); +x_54 = lean_alloc_ctor(6, 3, 8); +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_uint64(x_54, sizeof(void*)*3, x_46); +x_55 = (uint8_t)((x_46 << 24) >> 61); +x_56 = lean_expr_update_lambda(x_54, x_55, x_48, x_52); +x_57 = !lean_is_exclusive(x_53); +if (x_57 == 0) +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_58 = lean_ctor_get(x_53, 0); +x_59 = lean_ctor_get(x_53, 1); +x_60 = lean_array_uset(x_58, x_8, x_5); lean_inc(x_56); -lean_inc(x_5); -x_57 = lean_array_uset(x_56, x_8, x_5); -x_58 = !lean_is_exclusive(x_5); -if (x_58 == 0) +x_61 = lean_array_uset(x_59, x_8, x_56); +lean_ctor_set(x_53, 1, x_61); +lean_ctor_set(x_53, 0, x_60); +lean_ctor_set(x_50, 0, x_56); +return x_50; +} +else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; -x_59 = lean_ctor_get(x_5, 2); -lean_dec(x_59); -x_60 = lean_ctor_get(x_5, 1); -lean_dec(x_60); -x_61 = lean_ctor_get(x_5, 0); -lean_dec(x_61); -x_62 = lean_ctor_get(x_55, 1); +lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_62 = lean_ctor_get(x_53, 0); +x_63 = lean_ctor_get(x_53, 1); +lean_inc(x_63); lean_inc(x_62); -lean_dec(x_55); -x_63 = (uint8_t)((x_48 << 24) >> 61); -x_64 = lean_expr_update_lambda(x_5, x_63, x_50, x_54); -lean_inc(x_64); -x_65 = lean_array_uset(x_62, x_8, x_64); +lean_dec(x_53); +x_64 = lean_array_uset(x_62, x_8, x_5); +lean_inc(x_56); +x_65 = lean_array_uset(x_63, x_8, x_56); x_66 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_66, 0, x_57); +lean_ctor_set(x_66, 0, x_64); lean_ctor_set(x_66, 1, x_65); -lean_ctor_set(x_52, 1, x_66); -lean_ctor_set(x_52, 0, x_64); -return x_52; +lean_ctor_set(x_50, 1, x_66); +lean_ctor_set(x_50, 0, x_56); +return x_50; +} } else { -lean_object* x_67; lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; -lean_dec(x_5); -x_67 = lean_ctor_get(x_55, 1); +lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_67 = lean_ctor_get(x_50, 0); +x_68 = lean_ctor_get(x_50, 1); +lean_inc(x_68); lean_inc(x_67); -lean_dec(x_55); -x_68 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_68, 0, x_45); -lean_ctor_set(x_68, 1, x_46); -lean_ctor_set(x_68, 2, x_47); -lean_ctor_set_uint64(x_68, sizeof(void*)*3, x_48); -x_69 = (uint8_t)((x_48 << 24) >> 61); -x_70 = lean_expr_update_lambda(x_68, x_69, x_50, x_54); -lean_inc(x_70); -x_71 = lean_array_uset(x_67, x_8, x_70); -x_72 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_72, 0, x_57); -lean_ctor_set(x_72, 1, x_71); -lean_ctor_set(x_52, 1, x_72); -lean_ctor_set(x_52, 0, x_70); -return x_52; -} -} -else -{ -lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; -x_73 = lean_ctor_get(x_52, 0); -x_74 = lean_ctor_get(x_52, 1); -lean_inc(x_74); +lean_dec(x_50); +x_69 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_69, 0, x_43); +lean_ctor_set(x_69, 1, x_44); +lean_ctor_set(x_69, 2, x_45); +lean_ctor_set_uint64(x_69, sizeof(void*)*3, x_46); +x_70 = (uint8_t)((x_46 << 24) >> 61); +x_71 = lean_expr_update_lambda(x_69, x_70, x_48, x_67); +x_72 = lean_ctor_get(x_68, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_68, 1); lean_inc(x_73); -lean_dec(x_52); -x_75 = lean_ctor_get(x_74, 0); -lean_inc(x_75); -lean_inc(x_5); -x_76 = lean_array_uset(x_75, x_8, 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); - x_77 = x_5; +if (lean_is_exclusive(x_68)) { + lean_ctor_release(x_68, 0); + lean_ctor_release(x_68, 1); + x_74 = x_68; } else { - lean_dec_ref(x_5); - x_77 = lean_box(0); + lean_dec_ref(x_68); + x_74 = lean_box(0); } -x_78 = lean_ctor_get(x_74, 1); -lean_inc(x_78); -lean_dec(x_74); -if (lean_is_scalar(x_77)) { - x_79 = lean_alloc_ctor(6, 3, 8); +x_75 = lean_array_uset(x_72, x_8, x_5); +lean_inc(x_71); +x_76 = lean_array_uset(x_73, x_8, x_71); +if (lean_is_scalar(x_74)) { + x_77 = lean_alloc_ctor(0, 2, 0); } else { - x_79 = x_77; + x_77 = x_74; } -lean_ctor_set(x_79, 0, x_45); -lean_ctor_set(x_79, 1, x_46); -lean_ctor_set(x_79, 2, x_47); -lean_ctor_set_uint64(x_79, sizeof(void*)*3, x_48); -x_80 = (uint8_t)((x_48 << 24) >> 61); -x_81 = lean_expr_update_lambda(x_79, x_80, x_50, x_73); -lean_inc(x_81); -x_82 = lean_array_uset(x_78, x_8, x_81); -x_83 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_83, 0, x_76); -lean_ctor_set(x_83, 1, x_82); -x_84 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_84, 0, x_81); -lean_ctor_set(x_84, 1, x_83); -return x_84; +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set(x_77, 1, x_76); +x_78 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_78, 0, x_71); +lean_ctor_set(x_78, 1, x_77); +return x_78; } } case 7: { -lean_object* x_85; lean_object* x_86; lean_object* x_87; uint64_t x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; -x_85 = lean_ctor_get(x_5, 0); -lean_inc(x_85); -x_86 = lean_ctor_get(x_5, 1); -lean_inc(x_86); -x_87 = lean_ctor_get(x_5, 2); -lean_inc(x_87); -x_88 = lean_ctor_get_uint64(x_5, sizeof(void*)*3); -lean_inc(x_86); +lean_object* x_79; lean_object* x_80; lean_object* x_81; uint64_t x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; uint8_t x_87; +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_uint64(x_5, sizeof(void*)*3); +lean_inc(x_80); lean_inc(x_3); lean_inc(x_1); -x_89 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_86, x_6); -x_90 = lean_ctor_get(x_89, 0); -lean_inc(x_90); -x_91 = lean_ctor_get(x_89, 1); -lean_inc(x_91); -lean_dec(x_89); -lean_inc(x_87); -x_92 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_87, x_91); -x_93 = !lean_is_exclusive(x_92); +x_83 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_80, x_6); +x_84 = lean_ctor_get(x_83, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_83, 1); +lean_inc(x_85); +lean_dec(x_83); +lean_inc(x_81); +x_86 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_81, x_85); +x_87 = !lean_is_exclusive(x_86); +if (x_87 == 0) +{ +lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; lean_object* x_92; uint8_t x_93; +x_88 = lean_ctor_get(x_86, 0); +x_89 = lean_ctor_get(x_86, 1); +x_90 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_90, 0, x_79); +lean_ctor_set(x_90, 1, x_80); +lean_ctor_set(x_90, 2, x_81); +lean_ctor_set_uint64(x_90, sizeof(void*)*3, x_82); +x_91 = (uint8_t)((x_82 << 24) >> 61); +x_92 = lean_expr_update_forall(x_90, x_91, x_84, x_88); +x_93 = !lean_is_exclusive(x_89); if (x_93 == 0) { -lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; uint8_t x_98; -x_94 = lean_ctor_get(x_92, 0); -x_95 = lean_ctor_get(x_92, 1); -x_96 = lean_ctor_get(x_95, 0); -lean_inc(x_96); -lean_inc(x_5); -x_97 = lean_array_uset(x_96, x_8, x_5); -x_98 = !lean_is_exclusive(x_5); -if (x_98 == 0) +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_94 = lean_ctor_get(x_89, 0); +x_95 = lean_ctor_get(x_89, 1); +x_96 = lean_array_uset(x_94, x_8, x_5); +lean_inc(x_92); +x_97 = lean_array_uset(x_95, x_8, x_92); +lean_ctor_set(x_89, 1, x_97); +lean_ctor_set(x_89, 0, x_96); +lean_ctor_set(x_86, 0, x_92); +return x_86; +} +else { -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_105; lean_object* x_106; -x_99 = lean_ctor_get(x_5, 2); -lean_dec(x_99); -x_100 = lean_ctor_get(x_5, 1); -lean_dec(x_100); -x_101 = lean_ctor_get(x_5, 0); -lean_dec(x_101); -x_102 = lean_ctor_get(x_95, 1); -lean_inc(x_102); -lean_dec(x_95); -x_103 = (uint8_t)((x_88 << 24) >> 61); -x_104 = lean_expr_update_forall(x_5, x_103, x_90, x_94); +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; +x_98 = lean_ctor_get(x_89, 0); +x_99 = lean_ctor_get(x_89, 1); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_89); +x_100 = lean_array_uset(x_98, x_8, x_5); +lean_inc(x_92); +x_101 = lean_array_uset(x_99, x_8, x_92); +x_102 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_102, 0, x_100); +lean_ctor_set(x_102, 1, x_101); +lean_ctor_set(x_86, 1, x_102); +lean_ctor_set(x_86, 0, x_92); +return x_86; +} +} +else +{ +lean_object* x_103; lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; +x_103 = lean_ctor_get(x_86, 0); +x_104 = lean_ctor_get(x_86, 1); lean_inc(x_104); -x_105 = lean_array_uset(x_102, x_8, x_104); -x_106 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_106, 0, x_97); -lean_ctor_set(x_106, 1, x_105); -lean_ctor_set(x_92, 1, x_106); -lean_ctor_set(x_92, 0, x_104); -return x_92; +lean_inc(x_103); +lean_dec(x_86); +x_105 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_105, 0, x_79); +lean_ctor_set(x_105, 1, x_80); +lean_ctor_set(x_105, 2, x_81); +lean_ctor_set_uint64(x_105, sizeof(void*)*3, x_82); +x_106 = (uint8_t)((x_82 << 24) >> 61); +x_107 = lean_expr_update_forall(x_105, x_106, x_84, x_103); +x_108 = lean_ctor_get(x_104, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_104, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_104)) { + lean_ctor_release(x_104, 0); + lean_ctor_release(x_104, 1); + x_110 = x_104; +} else { + lean_dec_ref(x_104); + x_110 = lean_box(0); } -else -{ -lean_object* x_107; lean_object* x_108; uint8_t x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; -lean_dec(x_5); -x_107 = lean_ctor_get(x_95, 1); +x_111 = lean_array_uset(x_108, x_8, x_5); lean_inc(x_107); -lean_dec(x_95); -x_108 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_108, 0, x_85); -lean_ctor_set(x_108, 1, x_86); -lean_ctor_set(x_108, 2, x_87); -lean_ctor_set_uint64(x_108, sizeof(void*)*3, x_88); -x_109 = (uint8_t)((x_88 << 24) >> 61); -x_110 = lean_expr_update_forall(x_108, x_109, x_90, x_94); -lean_inc(x_110); -x_111 = lean_array_uset(x_107, x_8, x_110); -x_112 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_112, 0, x_97); -lean_ctor_set(x_112, 1, x_111); -lean_ctor_set(x_92, 1, x_112); -lean_ctor_set(x_92, 0, x_110); -return x_92; -} -} -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; uint8_t x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; -x_113 = lean_ctor_get(x_92, 0); -x_114 = lean_ctor_get(x_92, 1); -lean_inc(x_114); -lean_inc(x_113); -lean_dec(x_92); -x_115 = lean_ctor_get(x_114, 0); -lean_inc(x_115); -lean_inc(x_5); -x_116 = lean_array_uset(x_115, x_8, 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); - x_117 = x_5; +x_112 = lean_array_uset(x_109, x_8, x_107); +if (lean_is_scalar(x_110)) { + x_113 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_5); - x_117 = lean_box(0); + x_113 = x_110; } -x_118 = lean_ctor_get(x_114, 1); -lean_inc(x_118); -lean_dec(x_114); -if (lean_is_scalar(x_117)) { - x_119 = lean_alloc_ctor(7, 3, 8); -} else { - x_119 = x_117; -} -lean_ctor_set(x_119, 0, x_85); -lean_ctor_set(x_119, 1, x_86); -lean_ctor_set(x_119, 2, x_87); -lean_ctor_set_uint64(x_119, sizeof(void*)*3, x_88); -x_120 = (uint8_t)((x_88 << 24) >> 61); -x_121 = lean_expr_update_forall(x_119, x_120, x_90, x_113); -lean_inc(x_121); -x_122 = lean_array_uset(x_118, x_8, x_121); -x_123 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_123, 0, x_116); -lean_ctor_set(x_123, 1, x_122); -x_124 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_124, 0, x_121); -lean_ctor_set(x_124, 1, x_123); -return x_124; +lean_ctor_set(x_113, 0, x_111); +lean_ctor_set(x_113, 1, x_112); +x_114 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_114, 0, x_107); +lean_ctor_set(x_114, 1, x_113); +return x_114; } } case 8: { -lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; uint64_t 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; uint8_t x_137; -x_125 = lean_ctor_get(x_5, 0); +lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; uint64_t 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; uint8_t x_127; +x_115 = lean_ctor_get(x_5, 0); +lean_inc(x_115); +x_116 = lean_ctor_get(x_5, 1); +lean_inc(x_116); +x_117 = lean_ctor_get(x_5, 2); +lean_inc(x_117); +x_118 = lean_ctor_get(x_5, 3); +lean_inc(x_118); +x_119 = lean_ctor_get_uint64(x_5, sizeof(void*)*4); +lean_inc(x_116); +lean_inc(x_3); +lean_inc(x_1); +x_120 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_116, x_6); +x_121 = lean_ctor_get(x_120, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_120, 1); +lean_inc(x_122); +lean_dec(x_120); +lean_inc(x_117); +lean_inc(x_3); +lean_inc(x_1); +x_123 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_117, x_122); +x_124 = lean_ctor_get(x_123, 0); +lean_inc(x_124); +x_125 = lean_ctor_get(x_123, 1); lean_inc(x_125); -x_126 = lean_ctor_get(x_5, 1); -lean_inc(x_126); -x_127 = lean_ctor_get(x_5, 2); -lean_inc(x_127); -x_128 = lean_ctor_get(x_5, 3); -lean_inc(x_128); -x_129 = lean_ctor_get_uint64(x_5, sizeof(void*)*4); -lean_inc(x_126); -lean_inc(x_3); -lean_inc(x_1); -x_130 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_126, x_6); -x_131 = lean_ctor_get(x_130, 0); +lean_dec(x_123); +lean_inc(x_118); +x_126 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_118, x_125); +x_127 = !lean_is_exclusive(x_126); +if (x_127 == 0) +{ +lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; uint8_t x_132; +x_128 = lean_ctor_get(x_126, 0); +x_129 = lean_ctor_get(x_126, 1); +x_130 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_130, 0, x_115); +lean_ctor_set(x_130, 1, x_116); +lean_ctor_set(x_130, 2, x_117); +lean_ctor_set(x_130, 3, x_118); +lean_ctor_set_uint64(x_130, sizeof(void*)*4, x_119); +x_131 = lean_expr_update_let(x_130, x_121, x_124, x_128); +x_132 = !lean_is_exclusive(x_129); +if (x_132 == 0) +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; +x_133 = lean_ctor_get(x_129, 0); +x_134 = lean_ctor_get(x_129, 1); +x_135 = lean_array_uset(x_133, x_8, x_5); lean_inc(x_131); -x_132 = lean_ctor_get(x_130, 1); -lean_inc(x_132); -lean_dec(x_130); -lean_inc(x_127); -lean_inc(x_3); -lean_inc(x_1); -x_133 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_127, x_132); -x_134 = lean_ctor_get(x_133, 0); -lean_inc(x_134); -x_135 = lean_ctor_get(x_133, 1); -lean_inc(x_135); -lean_dec(x_133); -lean_inc(x_128); -x_136 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_128, x_135); -x_137 = !lean_is_exclusive(x_136); -if (x_137 == 0) +x_136 = lean_array_uset(x_134, x_8, x_131); +lean_ctor_set(x_129, 1, x_136); +lean_ctor_set(x_129, 0, x_135); +lean_ctor_set(x_126, 0, x_131); +return x_126; +} +else { -lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; uint8_t x_142; -x_138 = lean_ctor_get(x_136, 0); -x_139 = lean_ctor_get(x_136, 1); -x_140 = lean_ctor_get(x_139, 0); -lean_inc(x_140); -lean_inc(x_5); -x_141 = lean_array_uset(x_140, x_8, x_5); -x_142 = !lean_is_exclusive(x_5); -if (x_142 == 0) +lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; +x_137 = lean_ctor_get(x_129, 0); +x_138 = lean_ctor_get(x_129, 1); +lean_inc(x_138); +lean_inc(x_137); +lean_dec(x_129); +x_139 = lean_array_uset(x_137, x_8, x_5); +lean_inc(x_131); +x_140 = lean_array_uset(x_138, x_8, x_131); +x_141 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_141, 0, x_139); +lean_ctor_set(x_141, 1, x_140); +lean_ctor_set(x_126, 1, x_141); +lean_ctor_set(x_126, 0, x_131); +return x_126; +} +} +else { -lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; -x_143 = lean_ctor_get(x_5, 3); -lean_dec(x_143); -x_144 = lean_ctor_get(x_5, 2); -lean_dec(x_144); -x_145 = lean_ctor_get(x_5, 1); -lean_dec(x_145); -x_146 = lean_ctor_get(x_5, 0); -lean_dec(x_146); -x_147 = lean_ctor_get(x_139, 1); +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_126, 0); +x_143 = lean_ctor_get(x_126, 1); +lean_inc(x_143); +lean_inc(x_142); +lean_dec(x_126); +x_144 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_144, 0, x_115); +lean_ctor_set(x_144, 1, x_116); +lean_ctor_set(x_144, 2, x_117); +lean_ctor_set(x_144, 3, x_118); +lean_ctor_set_uint64(x_144, sizeof(void*)*4, x_119); +x_145 = lean_expr_update_let(x_144, x_121, x_124, x_142); +x_146 = lean_ctor_get(x_143, 0); +lean_inc(x_146); +x_147 = lean_ctor_get(x_143, 1); lean_inc(x_147); -lean_dec(x_139); -x_148 = lean_expr_update_let(x_5, x_131, x_134, x_138); -lean_inc(x_148); -x_149 = lean_array_uset(x_147, x_8, x_148); -x_150 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_150, 0, x_141); -lean_ctor_set(x_150, 1, x_149); -lean_ctor_set(x_136, 1, x_150); -lean_ctor_set(x_136, 0, x_148); -return x_136; -} -else -{ -lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; -lean_dec(x_5); -x_151 = lean_ctor_get(x_139, 1); -lean_inc(x_151); -lean_dec(x_139); -x_152 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_152, 0, x_125); -lean_ctor_set(x_152, 1, x_126); -lean_ctor_set(x_152, 2, x_127); -lean_ctor_set(x_152, 3, x_128); -lean_ctor_set_uint64(x_152, sizeof(void*)*4, x_129); -x_153 = lean_expr_update_let(x_152, x_131, x_134, x_138); -lean_inc(x_153); -x_154 = lean_array_uset(x_151, x_8, x_153); -x_155 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_155, 0, x_141); -lean_ctor_set(x_155, 1, x_154); -lean_ctor_set(x_136, 1, x_155); -lean_ctor_set(x_136, 0, x_153); -return x_136; -} -} -else -{ -lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; -x_156 = lean_ctor_get(x_136, 0); -x_157 = lean_ctor_get(x_136, 1); -lean_inc(x_157); -lean_inc(x_156); -lean_dec(x_136); -x_158 = lean_ctor_get(x_157, 0); -lean_inc(x_158); -lean_inc(x_5); -x_159 = lean_array_uset(x_158, x_8, 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_160 = x_5; +if (lean_is_exclusive(x_143)) { + lean_ctor_release(x_143, 0); + lean_ctor_release(x_143, 1); + x_148 = x_143; } else { - lean_dec_ref(x_5); - x_160 = lean_box(0); + lean_dec_ref(x_143); + x_148 = lean_box(0); } -x_161 = lean_ctor_get(x_157, 1); -lean_inc(x_161); -lean_dec(x_157); -if (lean_is_scalar(x_160)) { - x_162 = lean_alloc_ctor(8, 4, 8); +x_149 = lean_array_uset(x_146, x_8, x_5); +lean_inc(x_145); +x_150 = lean_array_uset(x_147, x_8, x_145); +if (lean_is_scalar(x_148)) { + x_151 = lean_alloc_ctor(0, 2, 0); } else { - x_162 = x_160; + x_151 = x_148; } -lean_ctor_set(x_162, 0, x_125); -lean_ctor_set(x_162, 1, x_126); -lean_ctor_set(x_162, 2, x_127); -lean_ctor_set(x_162, 3, x_128); -lean_ctor_set_uint64(x_162, sizeof(void*)*4, x_129); -x_163 = lean_expr_update_let(x_162, x_131, x_134, x_156); -lean_inc(x_163); -x_164 = lean_array_uset(x_161, x_8, x_163); -x_165 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_165, 0, x_159); -lean_ctor_set(x_165, 1, x_164); -x_166 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_166, 0, x_163); -lean_ctor_set(x_166, 1, x_165); -return x_166; +lean_ctor_set(x_151, 0, x_149); +lean_ctor_set(x_151, 1, x_150); +x_152 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_152, 0, x_145); +lean_ctor_set(x_152, 1, x_151); +return x_152; } } case 10: { -lean_object* x_167; lean_object* x_168; uint64_t x_169; lean_object* x_170; uint8_t x_171; -x_167 = lean_ctor_get(x_5, 0); +lean_object* x_153; lean_object* x_154; uint64_t x_155; lean_object* x_156; uint8_t x_157; +x_153 = lean_ctor_get(x_5, 0); +lean_inc(x_153); +x_154 = lean_ctor_get(x_5, 1); +lean_inc(x_154); +x_155 = lean_ctor_get_uint64(x_5, sizeof(void*)*2); +lean_inc(x_154); +x_156 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_154, x_6); +x_157 = !lean_is_exclusive(x_156); +if (x_157 == 0) +{ +lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; uint8_t x_162; +x_158 = lean_ctor_get(x_156, 0); +x_159 = lean_ctor_get(x_156, 1); +x_160 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_160, 0, x_153); +lean_ctor_set(x_160, 1, x_154); +lean_ctor_set_uint64(x_160, sizeof(void*)*2, x_155); +x_161 = lean_expr_update_mdata(x_160, x_158); +x_162 = !lean_is_exclusive(x_159); +if (x_162 == 0) +{ +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; +x_163 = lean_ctor_get(x_159, 0); +x_164 = lean_ctor_get(x_159, 1); +x_165 = lean_array_uset(x_163, x_8, x_5); +lean_inc(x_161); +x_166 = lean_array_uset(x_164, x_8, x_161); +lean_ctor_set(x_159, 1, x_166); +lean_ctor_set(x_159, 0, x_165); +lean_ctor_set(x_156, 0, x_161); +return x_156; +} +else +{ +lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; +x_167 = lean_ctor_get(x_159, 0); +x_168 = lean_ctor_get(x_159, 1); +lean_inc(x_168); lean_inc(x_167); -x_168 = lean_ctor_get(x_5, 1); -lean_inc(x_168); -x_169 = lean_ctor_get_uint64(x_5, sizeof(void*)*2); -lean_inc(x_168); -x_170 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_168, x_6); -x_171 = !lean_is_exclusive(x_170); -if (x_171 == 0) +lean_dec(x_159); +x_169 = lean_array_uset(x_167, x_8, x_5); +lean_inc(x_161); +x_170 = lean_array_uset(x_168, x_8, x_161); +x_171 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_171, 0, x_169); +lean_ctor_set(x_171, 1, x_170); +lean_ctor_set(x_156, 1, x_171); +lean_ctor_set(x_156, 0, x_161); +return x_156; +} +} +else { -lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; uint8_t x_176; -x_172 = lean_ctor_get(x_170, 0); -x_173 = lean_ctor_get(x_170, 1); -x_174 = lean_ctor_get(x_173, 0); -lean_inc(x_174); -lean_inc(x_5); -x_175 = lean_array_uset(x_174, x_8, x_5); -x_176 = !lean_is_exclusive(x_5); -if (x_176 == 0) -{ -lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; -x_177 = lean_ctor_get(x_5, 1); -lean_dec(x_177); -x_178 = lean_ctor_get(x_5, 0); -lean_dec(x_178); -x_179 = lean_ctor_get(x_173, 1); -lean_inc(x_179); -lean_dec(x_173); -x_180 = lean_expr_update_mdata(x_5, x_172); -lean_inc(x_180); -x_181 = lean_array_uset(x_179, x_8, x_180); +lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; +x_172 = lean_ctor_get(x_156, 0); +x_173 = lean_ctor_get(x_156, 1); +lean_inc(x_173); +lean_inc(x_172); +lean_dec(x_156); +x_174 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_174, 0, x_153); +lean_ctor_set(x_174, 1, x_154); +lean_ctor_set_uint64(x_174, sizeof(void*)*2, x_155); +x_175 = lean_expr_update_mdata(x_174, x_172); +x_176 = lean_ctor_get(x_173, 0); +lean_inc(x_176); +x_177 = lean_ctor_get(x_173, 1); +lean_inc(x_177); +if (lean_is_exclusive(x_173)) { + lean_ctor_release(x_173, 0); + lean_ctor_release(x_173, 1); + x_178 = x_173; +} else { + lean_dec_ref(x_173); + x_178 = lean_box(0); +} +x_179 = lean_array_uset(x_176, x_8, x_5); +lean_inc(x_175); +x_180 = lean_array_uset(x_177, x_8, x_175); +if (lean_is_scalar(x_178)) { + x_181 = lean_alloc_ctor(0, 2, 0); +} else { + x_181 = x_178; +} +lean_ctor_set(x_181, 0, x_179); +lean_ctor_set(x_181, 1, x_180); x_182 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_182, 0, x_175); lean_ctor_set(x_182, 1, x_181); -lean_ctor_set(x_170, 1, x_182); -lean_ctor_set(x_170, 0, x_180); -return x_170; -} -else -{ -lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; -lean_dec(x_5); -x_183 = lean_ctor_get(x_173, 1); -lean_inc(x_183); -lean_dec(x_173); -x_184 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_184, 0, x_167); -lean_ctor_set(x_184, 1, x_168); -lean_ctor_set_uint64(x_184, sizeof(void*)*2, x_169); -x_185 = lean_expr_update_mdata(x_184, x_172); -lean_inc(x_185); -x_186 = lean_array_uset(x_183, x_8, x_185); -x_187 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_187, 0, x_175); -lean_ctor_set(x_187, 1, x_186); -lean_ctor_set(x_170, 1, x_187); -lean_ctor_set(x_170, 0, x_185); -return x_170; -} -} -else -{ -lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; -x_188 = lean_ctor_get(x_170, 0); -x_189 = lean_ctor_get(x_170, 1); -lean_inc(x_189); -lean_inc(x_188); -lean_dec(x_170); -x_190 = lean_ctor_get(x_189, 0); -lean_inc(x_190); -lean_inc(x_5); -x_191 = lean_array_uset(x_190, x_8, x_5); -if (lean_is_exclusive(x_5)) { - lean_ctor_release(x_5, 0); - lean_ctor_release(x_5, 1); - x_192 = x_5; -} else { - lean_dec_ref(x_5); - x_192 = lean_box(0); -} -x_193 = lean_ctor_get(x_189, 1); -lean_inc(x_193); -lean_dec(x_189); -if (lean_is_scalar(x_192)) { - x_194 = lean_alloc_ctor(10, 2, 8); -} else { - x_194 = x_192; -} -lean_ctor_set(x_194, 0, x_167); -lean_ctor_set(x_194, 1, x_168); -lean_ctor_set_uint64(x_194, sizeof(void*)*2, x_169); -x_195 = lean_expr_update_mdata(x_194, x_188); -lean_inc(x_195); -x_196 = lean_array_uset(x_193, x_8, x_195); -x_197 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_197, 0, x_191); -lean_ctor_set(x_197, 1, x_196); -x_198 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_198, 0, x_195); -lean_ctor_set(x_198, 1, x_197); -return x_198; +return x_182; } } case 11: { -lean_object* x_199; lean_object* x_200; lean_object* x_201; uint64_t x_202; lean_object* x_203; uint8_t x_204; -x_199 = lean_ctor_get(x_5, 0); +lean_object* x_183; lean_object* x_184; lean_object* x_185; uint64_t x_186; lean_object* x_187; uint8_t x_188; +x_183 = lean_ctor_get(x_5, 0); +lean_inc(x_183); +x_184 = lean_ctor_get(x_5, 1); +lean_inc(x_184); +x_185 = lean_ctor_get(x_5, 2); +lean_inc(x_185); +x_186 = lean_ctor_get_uint64(x_5, sizeof(void*)*3); +lean_inc(x_185); +x_187 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_185, x_6); +x_188 = !lean_is_exclusive(x_187); +if (x_188 == 0) +{ +lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; uint8_t x_193; +x_189 = lean_ctor_get(x_187, 0); +x_190 = lean_ctor_get(x_187, 1); +x_191 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_191, 0, x_183); +lean_ctor_set(x_191, 1, x_184); +lean_ctor_set(x_191, 2, x_185); +lean_ctor_set_uint64(x_191, sizeof(void*)*3, x_186); +x_192 = lean_expr_update_proj(x_191, x_189); +x_193 = !lean_is_exclusive(x_190); +if (x_193 == 0) +{ +lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; +x_194 = lean_ctor_get(x_190, 0); +x_195 = lean_ctor_get(x_190, 1); +x_196 = lean_array_uset(x_194, x_8, x_5); +lean_inc(x_192); +x_197 = lean_array_uset(x_195, x_8, x_192); +lean_ctor_set(x_190, 1, x_197); +lean_ctor_set(x_190, 0, x_196); +lean_ctor_set(x_187, 0, x_192); +return x_187; +} +else +{ +lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; +x_198 = lean_ctor_get(x_190, 0); +x_199 = lean_ctor_get(x_190, 1); lean_inc(x_199); -x_200 = lean_ctor_get(x_5, 1); -lean_inc(x_200); -x_201 = lean_ctor_get(x_5, 2); -lean_inc(x_201); -x_202 = lean_ctor_get_uint64(x_5, sizeof(void*)*3); -lean_inc(x_201); -x_203 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at___private_Lean_Elab_Inductive_0__Lean_Elab_Command_replaceIndFVarsWithConsts___spec__1(x_1, x_2, x_3, x_4, x_201, x_6); -x_204 = !lean_is_exclusive(x_203); -if (x_204 == 0) +lean_inc(x_198); +lean_dec(x_190); +x_200 = lean_array_uset(x_198, x_8, x_5); +lean_inc(x_192); +x_201 = lean_array_uset(x_199, x_8, x_192); +x_202 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_202, 0, x_200); +lean_ctor_set(x_202, 1, x_201); +lean_ctor_set(x_187, 1, x_202); +lean_ctor_set(x_187, 0, x_192); +return x_187; +} +} +else { -lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; uint8_t x_209; -x_205 = lean_ctor_get(x_203, 0); -x_206 = lean_ctor_get(x_203, 1); -x_207 = lean_ctor_get(x_206, 0); +lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; +x_203 = lean_ctor_get(x_187, 0); +x_204 = lean_ctor_get(x_187, 1); +lean_inc(x_204); +lean_inc(x_203); +lean_dec(x_187); +x_205 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_205, 0, x_183); +lean_ctor_set(x_205, 1, x_184); +lean_ctor_set(x_205, 2, x_185); +lean_ctor_set_uint64(x_205, sizeof(void*)*3, x_186); +x_206 = lean_expr_update_proj(x_205, x_203); +x_207 = lean_ctor_get(x_204, 0); lean_inc(x_207); -lean_inc(x_5); -x_208 = lean_array_uset(x_207, x_8, x_5); -x_209 = !lean_is_exclusive(x_5); -if (x_209 == 0) -{ -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; -x_210 = lean_ctor_get(x_5, 2); -lean_dec(x_210); -x_211 = lean_ctor_get(x_5, 1); -lean_dec(x_211); -x_212 = lean_ctor_get(x_5, 0); -lean_dec(x_212); -x_213 = lean_ctor_get(x_206, 1); -lean_inc(x_213); -lean_dec(x_206); -x_214 = lean_expr_update_proj(x_5, x_205); -lean_inc(x_214); -x_215 = lean_array_uset(x_213, x_8, x_214); -x_216 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_216, 0, x_208); -lean_ctor_set(x_216, 1, x_215); -lean_ctor_set(x_203, 1, x_216); -lean_ctor_set(x_203, 0, x_214); -return x_203; -} -else -{ -lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; -lean_dec(x_5); -x_217 = lean_ctor_get(x_206, 1); -lean_inc(x_217); -lean_dec(x_206); -x_218 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_218, 0, x_199); -lean_ctor_set(x_218, 1, x_200); -lean_ctor_set(x_218, 2, x_201); -lean_ctor_set_uint64(x_218, sizeof(void*)*3, x_202); -x_219 = lean_expr_update_proj(x_218, x_205); -lean_inc(x_219); -x_220 = lean_array_uset(x_217, x_8, x_219); -x_221 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_221, 0, x_208); -lean_ctor_set(x_221, 1, x_220); -lean_ctor_set(x_203, 1, x_221); -lean_ctor_set(x_203, 0, x_219); -return x_203; -} -} -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; lean_object* x_232; -x_222 = lean_ctor_get(x_203, 0); -x_223 = lean_ctor_get(x_203, 1); -lean_inc(x_223); -lean_inc(x_222); -lean_dec(x_203); -x_224 = lean_ctor_get(x_223, 0); -lean_inc(x_224); -lean_inc(x_5); -x_225 = lean_array_uset(x_224, x_8, 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); - x_226 = x_5; +x_208 = lean_ctor_get(x_204, 1); +lean_inc(x_208); +if (lean_is_exclusive(x_204)) { + lean_ctor_release(x_204, 0); + lean_ctor_release(x_204, 1); + x_209 = x_204; } else { - lean_dec_ref(x_5); - x_226 = lean_box(0); + lean_dec_ref(x_204); + x_209 = lean_box(0); } -x_227 = lean_ctor_get(x_223, 1); -lean_inc(x_227); -lean_dec(x_223); -if (lean_is_scalar(x_226)) { - x_228 = lean_alloc_ctor(11, 3, 8); +x_210 = lean_array_uset(x_207, x_8, x_5); +lean_inc(x_206); +x_211 = lean_array_uset(x_208, x_8, x_206); +if (lean_is_scalar(x_209)) { + x_212 = lean_alloc_ctor(0, 2, 0); } else { - x_228 = x_226; + x_212 = x_209; } -lean_ctor_set(x_228, 0, x_199); -lean_ctor_set(x_228, 1, x_200); -lean_ctor_set(x_228, 2, x_201); -lean_ctor_set_uint64(x_228, sizeof(void*)*3, x_202); -x_229 = lean_expr_update_proj(x_228, x_222); -lean_inc(x_229); -x_230 = lean_array_uset(x_227, x_8, x_229); -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_225); -lean_ctor_set(x_231, 1, x_230); -x_232 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_232, 0, x_229); -lean_ctor_set(x_232, 1, x_231); -return x_232; +lean_ctor_set(x_212, 0, x_210); +lean_ctor_set(x_212, 1, x_211); +x_213 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_213, 0, x_206); +lean_ctor_set(x_213, 1, x_212); +return x_213; } } default: { -lean_object* x_233; +lean_object* x_214; lean_dec(x_3); lean_dec(x_1); -x_233 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_233, 0, x_5); -lean_ctor_set(x_233, 1, x_6); -return x_233; +x_214 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_214, 0, x_5); +lean_ctor_set(x_214, 1, x_6); +return x_214; } } } diff --git a/stage0/stdlib/Lean/Elab/MutualDef.c b/stage0/stdlib/Lean/Elab/MutualDef.c index 652ff876f4..6c4f85dae8 100644 --- a/stage0/stdlib/Lean/Elab/MutualDef.c +++ b/stage0/stdlib/Lean/Elab/MutualDef.c @@ -13639,77 +13639,97 @@ return x_2; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_233; lean_object* x_234; size_t x_235; uint8_t x_236; +size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_214; lean_object* x_215; size_t x_216; uint8_t x_217; x_5 = lean_ptr_addr(x_3); x_6 = x_2 == 0 ? x_5 : x_5 % x_2; -x_233 = lean_ctor_get(x_4, 0); -lean_inc(x_233); -x_234 = lean_array_uget(x_233, x_6); -x_235 = lean_ptr_addr(x_234); -lean_dec(x_234); -x_236 = x_235 == x_5; -if (x_236 == 0) +x_214 = lean_ctor_get(x_4, 0); +lean_inc(x_214); +x_215 = lean_array_uget(x_214, x_6); +lean_dec(x_214); +x_216 = lean_ptr_addr(x_215); +lean_dec(x_215); +x_217 = x_216 == x_5; +if (x_217 == 0) { if (lean_obj_tag(x_3) == 1) { -lean_object* x_237; lean_object* x_238; -x_237 = lean_ctor_get(x_3, 0); -lean_inc(x_237); -x_238 = l_Std_RBNode_find___at_Lean_Elab_Term_resolveName___spec__2(x_1, x_237); -lean_dec(x_237); -if (lean_obj_tag(x_238) == 0) +lean_object* x_218; lean_object* x_219; +x_218 = lean_ctor_get(x_3, 0); +lean_inc(x_218); +x_219 = l_Std_RBNode_find___at_Lean_Elab_Term_resolveName___spec__2(x_1, x_218); +lean_dec(x_218); +if (lean_obj_tag(x_219) == 0) { -lean_object* x_239; -lean_dec(x_233); -x_239 = lean_box(0); -x_7 = x_239; -goto block_232; +lean_object* x_220; +x_220 = lean_box(0); +x_7 = x_220; +goto block_213; } else { -lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; -x_240 = lean_ctor_get(x_238, 0); -lean_inc(x_240); -lean_dec(x_238); -x_241 = lean_array_uset(x_233, x_6, x_3); -x_242 = lean_ctor_get(x_4, 1); -lean_inc(x_242); +lean_object* x_221; uint8_t x_222; +x_221 = lean_ctor_get(x_219, 0); +lean_inc(x_221); +lean_dec(x_219); +x_222 = !lean_is_exclusive(x_4); +if (x_222 == 0) +{ +lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; +x_223 = lean_ctor_get(x_4, 0); +x_224 = lean_ctor_get(x_4, 1); +x_225 = lean_array_uset(x_223, x_6, x_3); +lean_inc(x_221); +x_226 = lean_array_uset(x_224, x_6, x_221); +lean_ctor_set(x_4, 1, x_226); +lean_ctor_set(x_4, 0, x_225); +x_227 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_227, 0, x_221); +lean_ctor_set(x_227, 1, x_4); +return x_227; +} +else +{ +lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; +x_228 = lean_ctor_get(x_4, 0); +x_229 = lean_ctor_get(x_4, 1); +lean_inc(x_229); +lean_inc(x_228); lean_dec(x_4); -lean_inc(x_240); -x_243 = lean_array_uset(x_242, x_6, x_240); -x_244 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_244, 0, x_241); -lean_ctor_set(x_244, 1, x_243); -x_245 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_245, 0, x_240); -lean_ctor_set(x_245, 1, x_244); -return x_245; +x_230 = lean_array_uset(x_228, x_6, x_3); +lean_inc(x_221); +x_231 = lean_array_uset(x_229, x_6, x_221); +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_230); +lean_ctor_set(x_232, 1, x_231); +x_233 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_233, 0, x_221); +lean_ctor_set(x_233, 1, x_232); +return x_233; +} } } else { -lean_object* x_246; -lean_dec(x_233); -x_246 = lean_box(0); -x_7 = x_246; -goto block_232; +lean_object* x_234; +x_234 = lean_box(0); +x_7 = x_234; +goto block_213; } } else { -lean_object* x_247; lean_object* x_248; lean_object* x_249; -lean_dec(x_233); +lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_dec(x_3); -x_247 = lean_ctor_get(x_4, 1); -lean_inc(x_247); -x_248 = lean_array_uget(x_247, x_6); -lean_dec(x_247); -x_249 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_249, 0, x_248); -lean_ctor_set(x_249, 1, x_4); -return x_249; +x_235 = lean_ctor_get(x_4, 1); +lean_inc(x_235); +x_236 = lean_array_uget(x_235, x_6); +lean_dec(x_235); +x_237 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_237, 0, x_236); +lean_ctor_set(x_237, 1, x_4); +return x_237; } -block_232: +block_213: { lean_dec(x_7); switch (lean_obj_tag(x_3)) { @@ -13736,702 +13756,619 @@ 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_14, 0); x_17 = lean_ctor_get(x_14, 1); -x_18 = lean_ctor_get(x_17, 0); -lean_inc(x_18); -lean_inc(x_3); -x_19 = lean_array_uset(x_18, x_6, x_3); -x_20 = !lean_is_exclusive(x_3); +x_18 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_18, 0, x_8); +lean_ctor_set(x_18, 1, x_9); +lean_ctor_set_uint64(x_18, sizeof(void*)*2, x_10); +x_19 = lean_expr_update_app(x_18, x_12, x_16); +x_20 = !lean_is_exclusive(x_17); if (x_20 == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -x_21 = lean_ctor_get(x_3, 1); -lean_dec(x_21); -x_22 = lean_ctor_get(x_3, 0); -lean_dec(x_22); -x_23 = lean_ctor_get(x_17, 1); -lean_inc(x_23); -lean_dec(x_17); -x_24 = lean_expr_update_app(x_3, x_12, x_16); -lean_inc(x_24); -x_25 = lean_array_uset(x_23, x_6, x_24); -x_26 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_26, 0, x_19); -lean_ctor_set(x_26, 1, x_25); -lean_ctor_set(x_14, 1, x_26); -lean_ctor_set(x_14, 0, x_24); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_17, 0); +x_22 = lean_ctor_get(x_17, 1); +x_23 = lean_array_uset(x_21, x_6, x_3); +lean_inc(x_19); +x_24 = lean_array_uset(x_22, x_6, x_19); +lean_ctor_set(x_17, 1, x_24); +lean_ctor_set(x_17, 0, x_23); +lean_ctor_set(x_14, 0, x_19); return x_14; } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_3); -x_27 = lean_ctor_get(x_17, 1); -lean_inc(x_27); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_17, 0); +x_26 = lean_ctor_get(x_17, 1); +lean_inc(x_26); +lean_inc(x_25); lean_dec(x_17); -x_28 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_28, 0, x_8); -lean_ctor_set(x_28, 1, x_9); -lean_ctor_set_uint64(x_28, sizeof(void*)*2, x_10); -x_29 = lean_expr_update_app(x_28, x_12, x_16); -lean_inc(x_29); -x_30 = lean_array_uset(x_27, x_6, x_29); -x_31 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_31, 0, x_19); -lean_ctor_set(x_31, 1, x_30); -lean_ctor_set(x_14, 1, x_31); -lean_ctor_set(x_14, 0, x_29); +x_27 = lean_array_uset(x_25, x_6, x_3); +lean_inc(x_19); +x_28 = lean_array_uset(x_26, x_6, x_19); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_14, 1, x_29); +lean_ctor_set(x_14, 0, x_19); return x_14; } } 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_14, 0); -x_33 = lean_ctor_get(x_14, 1); -lean_inc(x_33); -lean_inc(x_32); +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_30 = lean_ctor_get(x_14, 0); +x_31 = lean_ctor_get(x_14, 1); +lean_inc(x_31); +lean_inc(x_30); lean_dec(x_14); -x_34 = lean_ctor_get(x_33, 0); +x_32 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_32, 0, x_8); +lean_ctor_set(x_32, 1, x_9); +lean_ctor_set_uint64(x_32, sizeof(void*)*2, x_10); +x_33 = lean_expr_update_app(x_32, x_12, x_30); +x_34 = lean_ctor_get(x_31, 0); lean_inc(x_34); -lean_inc(x_3); -x_35 = lean_array_uset(x_34, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_36 = x_3; +x_35 = lean_ctor_get(x_31, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_36 = x_31; } else { - lean_dec_ref(x_3); + lean_dec_ref(x_31); x_36 = lean_box(0); } -x_37 = lean_ctor_get(x_33, 1); -lean_inc(x_37); -lean_dec(x_33); +x_37 = lean_array_uset(x_34, x_6, x_3); +lean_inc(x_33); +x_38 = lean_array_uset(x_35, x_6, x_33); if (lean_is_scalar(x_36)) { - x_38 = lean_alloc_ctor(5, 2, 8); + x_39 = lean_alloc_ctor(0, 2, 0); } else { - x_38 = x_36; + x_39 = x_36; } -lean_ctor_set(x_38, 0, x_8); -lean_ctor_set(x_38, 1, x_9); -lean_ctor_set_uint64(x_38, sizeof(void*)*2, x_10); -x_39 = lean_expr_update_app(x_38, x_12, x_32); -lean_inc(x_39); -x_40 = lean_array_uset(x_37, x_6, x_39); -x_41 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_41, 0, x_35); -lean_ctor_set(x_41, 1, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_39); -lean_ctor_set(x_42, 1, x_41); -return x_42; +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_33); +lean_ctor_set(x_40, 1, x_39); +return x_40; } } case 6: { -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_object* x_49; lean_object* x_50; uint8_t x_51; -x_43 = lean_ctor_get(x_3, 0); +lean_object* x_41; lean_object* x_42; lean_object* x_43; uint64_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_41 = lean_ctor_get(x_3, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_3, 1); +lean_inc(x_42); +x_43 = lean_ctor_get(x_3, 2); lean_inc(x_43); -x_44 = lean_ctor_get(x_3, 1); -lean_inc(x_44); -x_45 = lean_ctor_get(x_3, 2); -lean_inc(x_45); -x_46 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_44); -x_47 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_44, x_4); -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); -lean_inc(x_49); -lean_dec(x_47); -lean_inc(x_45); -x_50 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_45, x_49); -x_51 = !lean_is_exclusive(x_50); -if (x_51 == 0) +x_44 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_42); +x_45 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_42, x_4); +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +lean_inc(x_43); +x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_43, x_47); +x_49 = !lean_is_exclusive(x_48); +if (x_49 == 0) { -lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; -x_52 = lean_ctor_get(x_50, 0); -x_53 = lean_ctor_get(x_50, 1); -x_54 = lean_ctor_get(x_53, 0); +lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; +x_50 = lean_ctor_get(x_48, 0); +x_51 = lean_ctor_get(x_48, 1); +x_52 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_52, 0, x_41); +lean_ctor_set(x_52, 1, x_42); +lean_ctor_set(x_52, 2, x_43); +lean_ctor_set_uint64(x_52, sizeof(void*)*3, x_44); +x_53 = (uint8_t)((x_44 << 24) >> 61); +x_54 = lean_expr_update_lambda(x_52, x_53, x_46, x_50); +x_55 = !lean_is_exclusive(x_51); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_51, 0); +x_57 = lean_ctor_get(x_51, 1); +x_58 = lean_array_uset(x_56, x_6, x_3); lean_inc(x_54); -lean_inc(x_3); -x_55 = lean_array_uset(x_54, x_6, x_3); -x_56 = !lean_is_exclusive(x_3); -if (x_56 == 0) +x_59 = lean_array_uset(x_57, x_6, x_54); +lean_ctor_set(x_51, 1, x_59); +lean_ctor_set(x_51, 0, x_58); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} +else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; -x_57 = lean_ctor_get(x_3, 2); -lean_dec(x_57); -x_58 = lean_ctor_get(x_3, 1); -lean_dec(x_58); -x_59 = lean_ctor_get(x_3, 0); -lean_dec(x_59); -x_60 = lean_ctor_get(x_53, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_60 = lean_ctor_get(x_51, 0); +x_61 = lean_ctor_get(x_51, 1); +lean_inc(x_61); lean_inc(x_60); -lean_dec(x_53); -x_61 = (uint8_t)((x_46 << 24) >> 61); -x_62 = lean_expr_update_lambda(x_3, x_61, x_48, x_52); -lean_inc(x_62); -x_63 = lean_array_uset(x_60, x_6, x_62); +lean_dec(x_51); +x_62 = lean_array_uset(x_60, x_6, x_3); +lean_inc(x_54); +x_63 = lean_array_uset(x_61, x_6, x_54); x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_55); +lean_ctor_set(x_64, 0, x_62); lean_ctor_set(x_64, 1, x_63); -lean_ctor_set(x_50, 1, x_64); -lean_ctor_set(x_50, 0, x_62); -return x_50; +lean_ctor_set(x_48, 1, x_64); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} } else { -lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; -lean_dec(x_3); -x_65 = lean_ctor_get(x_53, 1); +lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_65 = lean_ctor_get(x_48, 0); +x_66 = lean_ctor_get(x_48, 1); +lean_inc(x_66); lean_inc(x_65); -lean_dec(x_53); -x_66 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_66, 0, x_43); -lean_ctor_set(x_66, 1, x_44); -lean_ctor_set(x_66, 2, x_45); -lean_ctor_set_uint64(x_66, sizeof(void*)*3, x_46); -x_67 = (uint8_t)((x_46 << 24) >> 61); -x_68 = lean_expr_update_lambda(x_66, x_67, x_48, x_52); -lean_inc(x_68); -x_69 = lean_array_uset(x_65, x_6, x_68); -x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_55); -lean_ctor_set(x_70, 1, x_69); -lean_ctor_set(x_50, 1, x_70); -lean_ctor_set(x_50, 0, x_68); -return x_50; -} -} -else -{ -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_71 = lean_ctor_get(x_50, 0); -x_72 = lean_ctor_get(x_50, 1); -lean_inc(x_72); +lean_dec(x_48); +x_67 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_67, 0, x_41); +lean_ctor_set(x_67, 1, x_42); +lean_ctor_set(x_67, 2, x_43); +lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_44); +x_68 = (uint8_t)((x_44 << 24) >> 61); +x_69 = lean_expr_update_lambda(x_67, x_68, x_46, x_65); +x_70 = lean_ctor_get(x_66, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_66, 1); lean_inc(x_71); -lean_dec(x_50); -x_73 = lean_ctor_get(x_72, 0); -lean_inc(x_73); -lean_inc(x_3); -x_74 = lean_array_uset(x_73, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_75 = x_3; +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + lean_ctor_release(x_66, 1); + x_72 = x_66; } else { - lean_dec_ref(x_3); - x_75 = lean_box(0); + lean_dec_ref(x_66); + x_72 = lean_box(0); } -x_76 = lean_ctor_get(x_72, 1); -lean_inc(x_76); -lean_dec(x_72); -if (lean_is_scalar(x_75)) { - x_77 = lean_alloc_ctor(6, 3, 8); +x_73 = lean_array_uset(x_70, x_6, x_3); +lean_inc(x_69); +x_74 = lean_array_uset(x_71, x_6, x_69); +if (lean_is_scalar(x_72)) { + x_75 = lean_alloc_ctor(0, 2, 0); } else { - x_77 = x_75; + x_75 = x_72; } -lean_ctor_set(x_77, 0, x_43); -lean_ctor_set(x_77, 1, x_44); -lean_ctor_set(x_77, 2, x_45); -lean_ctor_set_uint64(x_77, sizeof(void*)*3, x_46); -x_78 = (uint8_t)((x_46 << 24) >> 61); -x_79 = lean_expr_update_lambda(x_77, x_78, x_48, x_71); -lean_inc(x_79); -x_80 = lean_array_uset(x_76, x_6, x_79); -x_81 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_81, 0, x_74); -lean_ctor_set(x_81, 1, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_79); -lean_ctor_set(x_82, 1, x_81); -return x_82; +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set(x_75, 1, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_69); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } case 7: { -lean_object* x_83; lean_object* x_84; lean_object* x_85; uint64_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; -x_83 = lean_ctor_get(x_3, 0); +lean_object* x_77; lean_object* x_78; lean_object* x_79; uint64_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; +x_77 = lean_ctor_get(x_3, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_3, 1); +lean_inc(x_78); +x_79 = lean_ctor_get(x_3, 2); +lean_inc(x_79); +x_80 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_78); +x_81 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_78, x_4); +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); lean_inc(x_83); -x_84 = lean_ctor_get(x_3, 1); -lean_inc(x_84); -x_85 = lean_ctor_get(x_3, 2); -lean_inc(x_85); -x_86 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_84); -x_87 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_84, x_4); -x_88 = lean_ctor_get(x_87, 0); -lean_inc(x_88); -x_89 = lean_ctor_get(x_87, 1); -lean_inc(x_89); -lean_dec(x_87); -lean_inc(x_85); -x_90 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_85, x_89); -x_91 = !lean_is_exclusive(x_90); +lean_dec(x_81); +lean_inc(x_79); +x_84 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_79, x_83); +x_85 = !lean_is_exclusive(x_84); +if (x_85 == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; uint8_t x_89; lean_object* x_90; uint8_t x_91; +x_86 = lean_ctor_get(x_84, 0); +x_87 = lean_ctor_get(x_84, 1); +x_88 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_88, 0, x_77); +lean_ctor_set(x_88, 1, x_78); +lean_ctor_set(x_88, 2, x_79); +lean_ctor_set_uint64(x_88, sizeof(void*)*3, x_80); +x_89 = (uint8_t)((x_80 << 24) >> 61); +x_90 = lean_expr_update_forall(x_88, x_89, x_82, x_86); +x_91 = !lean_is_exclusive(x_87); if (x_91 == 0) { -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; uint8_t x_96; -x_92 = lean_ctor_get(x_90, 0); -x_93 = lean_ctor_get(x_90, 1); -x_94 = lean_ctor_get(x_93, 0); -lean_inc(x_94); -lean_inc(x_3); -x_95 = lean_array_uset(x_94, x_6, x_3); -x_96 = !lean_is_exclusive(x_3); -if (x_96 == 0) +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_92 = lean_ctor_get(x_87, 0); +x_93 = lean_ctor_get(x_87, 1); +x_94 = lean_array_uset(x_92, x_6, x_3); +lean_inc(x_90); +x_95 = lean_array_uset(x_93, x_6, x_90); +lean_ctor_set(x_87, 1, x_95); +lean_ctor_set(x_87, 0, x_94); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_97 = lean_ctor_get(x_3, 2); -lean_dec(x_97); -x_98 = lean_ctor_get(x_3, 1); -lean_dec(x_98); -x_99 = lean_ctor_get(x_3, 0); -lean_dec(x_99); -x_100 = lean_ctor_get(x_93, 1); -lean_inc(x_100); -lean_dec(x_93); -x_101 = (uint8_t)((x_86 << 24) >> 61); -x_102 = lean_expr_update_forall(x_3, x_101, x_88, x_92); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_96 = lean_ctor_get(x_87, 0); +x_97 = lean_ctor_get(x_87, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_87); +x_98 = lean_array_uset(x_96, x_6, x_3); +lean_inc(x_90); +x_99 = lean_array_uset(x_97, x_6, x_90); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +lean_ctor_set(x_84, 1, x_100); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_101 = lean_ctor_get(x_84, 0); +x_102 = lean_ctor_get(x_84, 1); lean_inc(x_102); -x_103 = lean_array_uset(x_100, x_6, x_102); -x_104 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_104, 0, x_95); -lean_ctor_set(x_104, 1, x_103); -lean_ctor_set(x_90, 1, x_104); -lean_ctor_set(x_90, 0, x_102); -return x_90; +lean_inc(x_101); +lean_dec(x_84); +x_103 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_103, 0, x_77); +lean_ctor_set(x_103, 1, x_78); +lean_ctor_set(x_103, 2, x_79); +lean_ctor_set_uint64(x_103, sizeof(void*)*3, x_80); +x_104 = (uint8_t)((x_80 << 24) >> 61); +x_105 = lean_expr_update_forall(x_103, x_104, x_82, x_101); +x_106 = lean_ctor_get(x_102, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_102, 1); +lean_inc(x_107); +if (lean_is_exclusive(x_102)) { + lean_ctor_release(x_102, 0); + lean_ctor_release(x_102, 1); + x_108 = x_102; +} else { + lean_dec_ref(x_102); + x_108 = lean_box(0); } -else -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_3); -x_105 = lean_ctor_get(x_93, 1); +x_109 = lean_array_uset(x_106, x_6, x_3); lean_inc(x_105); -lean_dec(x_93); -x_106 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_106, 0, x_83); -lean_ctor_set(x_106, 1, x_84); -lean_ctor_set(x_106, 2, x_85); -lean_ctor_set_uint64(x_106, sizeof(void*)*3, x_86); -x_107 = (uint8_t)((x_86 << 24) >> 61); -x_108 = lean_expr_update_forall(x_106, x_107, x_88, x_92); -lean_inc(x_108); -x_109 = lean_array_uset(x_105, x_6, x_108); -x_110 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_110, 0, x_95); -lean_ctor_set(x_110, 1, x_109); -lean_ctor_set(x_90, 1, x_110); -lean_ctor_set(x_90, 0, x_108); -return x_90; -} -} -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; uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; -x_111 = lean_ctor_get(x_90, 0); -x_112 = lean_ctor_get(x_90, 1); -lean_inc(x_112); -lean_inc(x_111); -lean_dec(x_90); -x_113 = lean_ctor_get(x_112, 0); -lean_inc(x_113); -lean_inc(x_3); -x_114 = lean_array_uset(x_113, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_115 = x_3; +x_110 = lean_array_uset(x_107, x_6, x_105); +if (lean_is_scalar(x_108)) { + x_111 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_3); - x_115 = lean_box(0); + x_111 = x_108; } -x_116 = lean_ctor_get(x_112, 1); -lean_inc(x_116); -lean_dec(x_112); -if (lean_is_scalar(x_115)) { - x_117 = lean_alloc_ctor(7, 3, 8); -} else { - x_117 = x_115; -} -lean_ctor_set(x_117, 0, x_83); -lean_ctor_set(x_117, 1, x_84); -lean_ctor_set(x_117, 2, x_85); -lean_ctor_set_uint64(x_117, sizeof(void*)*3, x_86); -x_118 = (uint8_t)((x_86 << 24) >> 61); -x_119 = lean_expr_update_forall(x_117, x_118, x_88, x_111); -lean_inc(x_119); -x_120 = lean_array_uset(x_116, x_6, x_119); -x_121 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_121, 0, x_114); -lean_ctor_set(x_121, 1, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_119); -lean_ctor_set(x_122, 1, x_121); -return x_122; +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set(x_112, 1, x_111); +return x_112; } } case 8: { -lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint64_t 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; uint8_t x_135; -x_123 = lean_ctor_get(x_3, 0); +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint64_t 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; uint8_t x_125; +x_113 = lean_ctor_get(x_3, 0); +lean_inc(x_113); +x_114 = lean_ctor_get(x_3, 1); +lean_inc(x_114); +x_115 = lean_ctor_get(x_3, 2); +lean_inc(x_115); +x_116 = lean_ctor_get(x_3, 3); +lean_inc(x_116); +x_117 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); +lean_inc(x_114); +x_118 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_114, x_4); +x_119 = lean_ctor_get(x_118, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_118, 1); +lean_inc(x_120); +lean_dec(x_118); +lean_inc(x_115); +x_121 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_115, x_120); +x_122 = lean_ctor_get(x_121, 0); +lean_inc(x_122); +x_123 = lean_ctor_get(x_121, 1); lean_inc(x_123); -x_124 = lean_ctor_get(x_3, 1); -lean_inc(x_124); -x_125 = lean_ctor_get(x_3, 2); -lean_inc(x_125); -x_126 = lean_ctor_get(x_3, 3); -lean_inc(x_126); -x_127 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); -lean_inc(x_124); -x_128 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_124, x_4); -x_129 = lean_ctor_get(x_128, 0); +lean_dec(x_121); +lean_inc(x_116); +x_124 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_116, x_123); +x_125 = !lean_is_exclusive(x_124); +if (x_125 == 0) +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; +x_126 = lean_ctor_get(x_124, 0); +x_127 = lean_ctor_get(x_124, 1); +x_128 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_128, 0, x_113); +lean_ctor_set(x_128, 1, x_114); +lean_ctor_set(x_128, 2, x_115); +lean_ctor_set(x_128, 3, x_116); +lean_ctor_set_uint64(x_128, sizeof(void*)*4, x_117); +x_129 = lean_expr_update_let(x_128, x_119, x_122, x_126); +x_130 = !lean_is_exclusive(x_127); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_131 = lean_ctor_get(x_127, 0); +x_132 = lean_ctor_get(x_127, 1); +x_133 = lean_array_uset(x_131, x_6, x_3); lean_inc(x_129); -x_130 = lean_ctor_get(x_128, 1); -lean_inc(x_130); -lean_dec(x_128); -lean_inc(x_125); -x_131 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_125, x_130); -x_132 = lean_ctor_get(x_131, 0); -lean_inc(x_132); -x_133 = lean_ctor_get(x_131, 1); -lean_inc(x_133); -lean_dec(x_131); -lean_inc(x_126); -x_134 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_126, x_133); -x_135 = !lean_is_exclusive(x_134); -if (x_135 == 0) +x_134 = lean_array_uset(x_132, x_6, x_129); +lean_ctor_set(x_127, 1, x_134); +lean_ctor_set(x_127, 0, x_133); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +else { -lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; uint8_t x_140; -x_136 = lean_ctor_get(x_134, 0); -x_137 = lean_ctor_get(x_134, 1); -x_138 = lean_ctor_get(x_137, 0); -lean_inc(x_138); -lean_inc(x_3); -x_139 = lean_array_uset(x_138, x_6, x_3); -x_140 = !lean_is_exclusive(x_3); -if (x_140 == 0) +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_135 = lean_ctor_get(x_127, 0); +x_136 = lean_ctor_get(x_127, 1); +lean_inc(x_136); +lean_inc(x_135); +lean_dec(x_127); +x_137 = lean_array_uset(x_135, x_6, x_3); +lean_inc(x_129); +x_138 = lean_array_uset(x_136, x_6, x_129); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set(x_139, 1, x_138); +lean_ctor_set(x_124, 1, x_139); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +} +else { -lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; -x_141 = lean_ctor_get(x_3, 3); -lean_dec(x_141); -x_142 = lean_ctor_get(x_3, 2); -lean_dec(x_142); -x_143 = lean_ctor_get(x_3, 1); -lean_dec(x_143); -x_144 = lean_ctor_get(x_3, 0); -lean_dec(x_144); -x_145 = lean_ctor_get(x_137, 1); +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_140 = lean_ctor_get(x_124, 0); +x_141 = lean_ctor_get(x_124, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_124); +x_142 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_142, 0, x_113); +lean_ctor_set(x_142, 1, x_114); +lean_ctor_set(x_142, 2, x_115); +lean_ctor_set(x_142, 3, x_116); +lean_ctor_set_uint64(x_142, sizeof(void*)*4, x_117); +x_143 = lean_expr_update_let(x_142, x_119, x_122, x_140); +x_144 = lean_ctor_get(x_141, 0); +lean_inc(x_144); +x_145 = lean_ctor_get(x_141, 1); lean_inc(x_145); -lean_dec(x_137); -x_146 = lean_expr_update_let(x_3, x_129, x_132, x_136); -lean_inc(x_146); -x_147 = lean_array_uset(x_145, x_6, x_146); -x_148 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_148, 0, x_139); -lean_ctor_set(x_148, 1, x_147); -lean_ctor_set(x_134, 1, x_148); -lean_ctor_set(x_134, 0, x_146); -return x_134; -} -else -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; -lean_dec(x_3); -x_149 = lean_ctor_get(x_137, 1); -lean_inc(x_149); -lean_dec(x_137); -x_150 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_150, 0, x_123); -lean_ctor_set(x_150, 1, x_124); -lean_ctor_set(x_150, 2, x_125); -lean_ctor_set(x_150, 3, x_126); -lean_ctor_set_uint64(x_150, sizeof(void*)*4, x_127); -x_151 = lean_expr_update_let(x_150, x_129, x_132, x_136); -lean_inc(x_151); -x_152 = lean_array_uset(x_149, x_6, x_151); -x_153 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_153, 0, x_139); -lean_ctor_set(x_153, 1, x_152); -lean_ctor_set(x_134, 1, x_153); -lean_ctor_set(x_134, 0, x_151); -return x_134; -} -} -else -{ -lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; -x_154 = lean_ctor_get(x_134, 0); -x_155 = lean_ctor_get(x_134, 1); -lean_inc(x_155); -lean_inc(x_154); -lean_dec(x_134); -x_156 = lean_ctor_get(x_155, 0); -lean_inc(x_156); -lean_inc(x_3); -x_157 = lean_array_uset(x_156, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - x_158 = x_3; +if (lean_is_exclusive(x_141)) { + lean_ctor_release(x_141, 0); + lean_ctor_release(x_141, 1); + x_146 = x_141; } else { - lean_dec_ref(x_3); - x_158 = lean_box(0); + lean_dec_ref(x_141); + x_146 = lean_box(0); } -x_159 = lean_ctor_get(x_155, 1); -lean_inc(x_159); -lean_dec(x_155); -if (lean_is_scalar(x_158)) { - x_160 = lean_alloc_ctor(8, 4, 8); +x_147 = lean_array_uset(x_144, x_6, x_3); +lean_inc(x_143); +x_148 = lean_array_uset(x_145, x_6, x_143); +if (lean_is_scalar(x_146)) { + x_149 = lean_alloc_ctor(0, 2, 0); } else { - x_160 = x_158; + x_149 = x_146; } -lean_ctor_set(x_160, 0, x_123); -lean_ctor_set(x_160, 1, x_124); -lean_ctor_set(x_160, 2, x_125); -lean_ctor_set(x_160, 3, x_126); -lean_ctor_set_uint64(x_160, sizeof(void*)*4, x_127); -x_161 = lean_expr_update_let(x_160, x_129, x_132, x_154); -lean_inc(x_161); -x_162 = lean_array_uset(x_159, x_6, x_161); -x_163 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_163, 0, x_157); -lean_ctor_set(x_163, 1, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_161); -lean_ctor_set(x_164, 1, x_163); -return x_164; +lean_ctor_set(x_149, 0, x_147); +lean_ctor_set(x_149, 1, x_148); +x_150 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_150, 0, x_143); +lean_ctor_set(x_150, 1, x_149); +return x_150; } } case 10: { -lean_object* x_165; lean_object* x_166; uint64_t x_167; lean_object* x_168; uint8_t x_169; -x_165 = lean_ctor_get(x_3, 0); +lean_object* x_151; lean_object* x_152; uint64_t x_153; lean_object* x_154; uint8_t x_155; +x_151 = lean_ctor_get(x_3, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_3, 1); +lean_inc(x_152); +x_153 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); +lean_inc(x_152); +x_154 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_152, x_4); +x_155 = !lean_is_exclusive(x_154); +if (x_155 == 0) +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; uint8_t x_160; +x_156 = lean_ctor_get(x_154, 0); +x_157 = lean_ctor_get(x_154, 1); +x_158 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_158, 0, x_151); +lean_ctor_set(x_158, 1, x_152); +lean_ctor_set_uint64(x_158, sizeof(void*)*2, x_153); +x_159 = lean_expr_update_mdata(x_158, x_156); +x_160 = !lean_is_exclusive(x_157); +if (x_160 == 0) +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_157, 0); +x_162 = lean_ctor_get(x_157, 1); +x_163 = lean_array_uset(x_161, x_6, x_3); +lean_inc(x_159); +x_164 = lean_array_uset(x_162, x_6, x_159); +lean_ctor_set(x_157, 1, x_164); +lean_ctor_set(x_157, 0, x_163); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +else +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_165 = lean_ctor_get(x_157, 0); +x_166 = lean_ctor_get(x_157, 1); +lean_inc(x_166); lean_inc(x_165); -x_166 = lean_ctor_get(x_3, 1); -lean_inc(x_166); -x_167 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); -lean_inc(x_166); -x_168 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_166, x_4); -x_169 = !lean_is_exclusive(x_168); -if (x_169 == 0) +lean_dec(x_157); +x_167 = lean_array_uset(x_165, x_6, x_3); +lean_inc(x_159); +x_168 = lean_array_uset(x_166, x_6, x_159); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_167); +lean_ctor_set(x_169, 1, x_168); +lean_ctor_set(x_154, 1, x_169); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +} +else { -lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; -x_170 = lean_ctor_get(x_168, 0); -x_171 = lean_ctor_get(x_168, 1); -x_172 = lean_ctor_get(x_171, 0); -lean_inc(x_172); -lean_inc(x_3); -x_173 = lean_array_uset(x_172, x_6, x_3); -x_174 = !lean_is_exclusive(x_3); -if (x_174 == 0) -{ -lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; -x_175 = lean_ctor_get(x_3, 1); -lean_dec(x_175); -x_176 = lean_ctor_get(x_3, 0); -lean_dec(x_176); -x_177 = lean_ctor_get(x_171, 1); -lean_inc(x_177); -lean_dec(x_171); -x_178 = lean_expr_update_mdata(x_3, x_170); -lean_inc(x_178); -x_179 = lean_array_uset(x_177, x_6, x_178); +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_170 = lean_ctor_get(x_154, 0); +x_171 = lean_ctor_get(x_154, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_154); +x_172 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_172, 0, x_151); +lean_ctor_set(x_172, 1, x_152); +lean_ctor_set_uint64(x_172, sizeof(void*)*2, x_153); +x_173 = lean_expr_update_mdata(x_172, x_170); +x_174 = lean_ctor_get(x_171, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_171, 1); +lean_inc(x_175); +if (lean_is_exclusive(x_171)) { + lean_ctor_release(x_171, 0); + lean_ctor_release(x_171, 1); + x_176 = x_171; +} else { + lean_dec_ref(x_171); + x_176 = lean_box(0); +} +x_177 = lean_array_uset(x_174, x_6, x_3); +lean_inc(x_173); +x_178 = lean_array_uset(x_175, x_6, x_173); +if (lean_is_scalar(x_176)) { + x_179 = lean_alloc_ctor(0, 2, 0); +} else { + x_179 = x_176; +} +lean_ctor_set(x_179, 0, x_177); +lean_ctor_set(x_179, 1, x_178); x_180 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_180, 0, x_173); lean_ctor_set(x_180, 1, x_179); -lean_ctor_set(x_168, 1, x_180); -lean_ctor_set(x_168, 0, x_178); -return x_168; -} -else -{ -lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; -lean_dec(x_3); -x_181 = lean_ctor_get(x_171, 1); -lean_inc(x_181); -lean_dec(x_171); -x_182 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_182, 0, x_165); -lean_ctor_set(x_182, 1, x_166); -lean_ctor_set_uint64(x_182, sizeof(void*)*2, x_167); -x_183 = lean_expr_update_mdata(x_182, x_170); -lean_inc(x_183); -x_184 = lean_array_uset(x_181, x_6, x_183); -x_185 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_185, 0, x_173); -lean_ctor_set(x_185, 1, x_184); -lean_ctor_set(x_168, 1, x_185); -lean_ctor_set(x_168, 0, x_183); -return x_168; -} -} -else -{ -lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; -x_186 = lean_ctor_get(x_168, 0); -x_187 = lean_ctor_get(x_168, 1); -lean_inc(x_187); -lean_inc(x_186); -lean_dec(x_168); -x_188 = lean_ctor_get(x_187, 0); -lean_inc(x_188); -lean_inc(x_3); -x_189 = lean_array_uset(x_188, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_190 = x_3; -} else { - lean_dec_ref(x_3); - x_190 = lean_box(0); -} -x_191 = lean_ctor_get(x_187, 1); -lean_inc(x_191); -lean_dec(x_187); -if (lean_is_scalar(x_190)) { - x_192 = lean_alloc_ctor(10, 2, 8); -} else { - x_192 = x_190; -} -lean_ctor_set(x_192, 0, x_165); -lean_ctor_set(x_192, 1, x_166); -lean_ctor_set_uint64(x_192, sizeof(void*)*2, x_167); -x_193 = lean_expr_update_mdata(x_192, x_186); -lean_inc(x_193); -x_194 = lean_array_uset(x_191, x_6, x_193); -x_195 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_195, 0, x_189); -lean_ctor_set(x_195, 1, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_193); -lean_ctor_set(x_196, 1, x_195); -return x_196; +return x_180; } } case 11: { -lean_object* x_197; lean_object* x_198; lean_object* x_199; uint64_t x_200; lean_object* x_201; uint8_t x_202; -x_197 = lean_ctor_get(x_3, 0); +lean_object* x_181; lean_object* x_182; lean_object* x_183; uint64_t x_184; lean_object* x_185; uint8_t x_186; +x_181 = lean_ctor_get(x_3, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_3, 1); +lean_inc(x_182); +x_183 = lean_ctor_get(x_3, 2); +lean_inc(x_183); +x_184 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_183); +x_185 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_183, x_4); +x_186 = !lean_is_exclusive(x_185); +if (x_186 == 0) +{ +lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; +x_187 = lean_ctor_get(x_185, 0); +x_188 = lean_ctor_get(x_185, 1); +x_189 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_189, 0, x_181); +lean_ctor_set(x_189, 1, x_182); +lean_ctor_set(x_189, 2, x_183); +lean_ctor_set_uint64(x_189, sizeof(void*)*3, x_184); +x_190 = lean_expr_update_proj(x_189, x_187); +x_191 = !lean_is_exclusive(x_188); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; +x_192 = lean_ctor_get(x_188, 0); +x_193 = lean_ctor_get(x_188, 1); +x_194 = lean_array_uset(x_192, x_6, x_3); +lean_inc(x_190); +x_195 = lean_array_uset(x_193, x_6, x_190); +lean_ctor_set(x_188, 1, x_195); +lean_ctor_set(x_188, 0, x_194); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +else +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +x_196 = lean_ctor_get(x_188, 0); +x_197 = lean_ctor_get(x_188, 1); lean_inc(x_197); -x_198 = lean_ctor_get(x_3, 1); -lean_inc(x_198); -x_199 = lean_ctor_get(x_3, 2); -lean_inc(x_199); -x_200 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_199); -x_201 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_Term_MutualClosure_Replacement_apply___spec__1(x_1, x_2, x_199, x_4); -x_202 = !lean_is_exclusive(x_201); -if (x_202 == 0) +lean_inc(x_196); +lean_dec(x_188); +x_198 = lean_array_uset(x_196, x_6, x_3); +lean_inc(x_190); +x_199 = lean_array_uset(x_197, x_6, x_190); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_198); +lean_ctor_set(x_200, 1, x_199); +lean_ctor_set(x_185, 1, x_200); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +} +else { -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_201, 0); -x_204 = lean_ctor_get(x_201, 1); -x_205 = lean_ctor_get(x_204, 0); +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; lean_object* x_211; +x_201 = lean_ctor_get(x_185, 0); +x_202 = lean_ctor_get(x_185, 1); +lean_inc(x_202); +lean_inc(x_201); +lean_dec(x_185); +x_203 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_203, 0, x_181); +lean_ctor_set(x_203, 1, x_182); +lean_ctor_set(x_203, 2, x_183); +lean_ctor_set_uint64(x_203, sizeof(void*)*3, x_184); +x_204 = lean_expr_update_proj(x_203, x_201); +x_205 = lean_ctor_get(x_202, 0); lean_inc(x_205); -lean_inc(x_3); -x_206 = lean_array_uset(x_205, x_6, x_3); -x_207 = !lean_is_exclusive(x_3); -if (x_207 == 0) -{ -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; -x_208 = lean_ctor_get(x_3, 2); -lean_dec(x_208); -x_209 = lean_ctor_get(x_3, 1); -lean_dec(x_209); -x_210 = lean_ctor_get(x_3, 0); -lean_dec(x_210); -x_211 = lean_ctor_get(x_204, 1); -lean_inc(x_211); -lean_dec(x_204); -x_212 = lean_expr_update_proj(x_3, x_203); -lean_inc(x_212); -x_213 = lean_array_uset(x_211, x_6, x_212); -x_214 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_214, 0, x_206); -lean_ctor_set(x_214, 1, x_213); -lean_ctor_set(x_201, 1, x_214); -lean_ctor_set(x_201, 0, x_212); -return x_201; -} -else -{ -lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; -lean_dec(x_3); -x_215 = lean_ctor_get(x_204, 1); -lean_inc(x_215); -lean_dec(x_204); -x_216 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_216, 0, x_197); -lean_ctor_set(x_216, 1, x_198); -lean_ctor_set(x_216, 2, x_199); -lean_ctor_set_uint64(x_216, sizeof(void*)*3, x_200); -x_217 = lean_expr_update_proj(x_216, x_203); -lean_inc(x_217); -x_218 = lean_array_uset(x_215, x_6, x_217); -x_219 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_219, 0, x_206); -lean_ctor_set(x_219, 1, x_218); -lean_ctor_set(x_201, 1, x_219); -lean_ctor_set(x_201, 0, x_217); -return x_201; -} -} -else -{ -lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; -x_220 = lean_ctor_get(x_201, 0); -x_221 = lean_ctor_get(x_201, 1); -lean_inc(x_221); -lean_inc(x_220); -lean_dec(x_201); -x_222 = lean_ctor_get(x_221, 0); -lean_inc(x_222); -lean_inc(x_3); -x_223 = lean_array_uset(x_222, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_224 = x_3; +x_206 = lean_ctor_get(x_202, 1); +lean_inc(x_206); +if (lean_is_exclusive(x_202)) { + lean_ctor_release(x_202, 0); + lean_ctor_release(x_202, 1); + x_207 = x_202; } else { - lean_dec_ref(x_3); - x_224 = lean_box(0); + lean_dec_ref(x_202); + x_207 = lean_box(0); } -x_225 = lean_ctor_get(x_221, 1); -lean_inc(x_225); -lean_dec(x_221); -if (lean_is_scalar(x_224)) { - x_226 = lean_alloc_ctor(11, 3, 8); +x_208 = lean_array_uset(x_205, x_6, x_3); +lean_inc(x_204); +x_209 = lean_array_uset(x_206, x_6, x_204); +if (lean_is_scalar(x_207)) { + x_210 = lean_alloc_ctor(0, 2, 0); } else { - x_226 = x_224; + x_210 = x_207; } -lean_ctor_set(x_226, 0, x_197); -lean_ctor_set(x_226, 1, x_198); -lean_ctor_set(x_226, 2, x_199); -lean_ctor_set_uint64(x_226, sizeof(void*)*3, x_200); -x_227 = lean_expr_update_proj(x_226, x_220); -lean_inc(x_227); -x_228 = lean_array_uset(x_225, x_6, x_227); -x_229 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_229, 0, x_223); -lean_ctor_set(x_229, 1, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_227); -lean_ctor_set(x_230, 1, x_229); -return x_230; +lean_ctor_set(x_210, 0, x_208); +lean_ctor_set(x_210, 1, x_209); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_204); +lean_ctor_set(x_211, 1, x_210); +return x_211; } } default: { -lean_object* x_231; -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_3); -lean_ctor_set(x_231, 1, x_4); -return x_231; +lean_object* x_212; +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_3); +lean_ctor_set(x_212, 1, x_4); +return x_212; } } } diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c b/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c index b326d39d1b..756e91eb67 100644 --- a/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c +++ b/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c @@ -1251,82 +1251,102 @@ return x_4; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, lean_object* x_4, lean_object* x_5) { _start: { -size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_234; lean_object* x_235; size_t x_236; uint8_t x_237; +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_215; lean_object* x_216; size_t x_217; uint8_t x_218; x_6 = lean_ptr_addr(x_4); x_7 = x_3 == 0 ? x_6 : x_6 % x_3; -x_234 = lean_ctor_get(x_5, 0); -lean_inc(x_234); -x_235 = lean_array_uget(x_234, x_7); -x_236 = lean_ptr_addr(x_235); -lean_dec(x_235); -x_237 = x_236 == x_6; -if (x_237 == 0) +x_215 = lean_ctor_get(x_5, 0); +lean_inc(x_215); +x_216 = lean_array_uget(x_215, x_7); +lean_dec(x_215); +x_217 = lean_ptr_addr(x_216); +lean_dec(x_216); +x_218 = x_217 == x_6; +if (x_218 == 0) { if (lean_obj_tag(x_4) == 4) { -lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; uint8_t x_242; -x_238 = lean_ctor_get(x_4, 0); -lean_inc(x_238); -lean_inc(x_238); -x_239 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1___lambda__1___boxed), 2, 1); -lean_closure_set(x_239, 0, x_238); -x_240 = lean_array_get_size(x_1); -x_241 = lean_unsigned_to_nat(0u); -x_242 = l_Array_anyMUnsafe___at_Array_any___spec__1___rarg(x_239, x_1, x_241, x_240); -lean_dec(x_240); -if (x_242 == 0) +lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; uint8_t x_223; +x_219 = lean_ctor_get(x_4, 0); +lean_inc(x_219); +lean_inc(x_219); +x_220 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1___lambda__1___boxed), 2, 1); +lean_closure_set(x_220, 0, x_219); +x_221 = lean_array_get_size(x_1); +x_222 = lean_unsigned_to_nat(0u); +x_223 = l_Array_anyMUnsafe___at_Array_any___spec__1___rarg(x_220, x_1, x_222, x_221); +lean_dec(x_221); +if (x_223 == 0) { -lean_object* x_243; -lean_dec(x_238); -lean_dec(x_234); -x_243 = lean_box(0); -x_8 = x_243; -goto block_233; +lean_object* x_224; +lean_dec(x_219); +x_224 = lean_box(0); +x_8 = x_224; +goto block_214; } else { -lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; -x_244 = l_Lean_mkConst(x_238, x_2); -x_245 = lean_array_uset(x_234, x_7, x_4); -x_246 = lean_ctor_get(x_5, 1); -lean_inc(x_246); +lean_object* x_225; uint8_t x_226; +x_225 = l_Lean_mkConst(x_219, x_2); +x_226 = !lean_is_exclusive(x_5); +if (x_226 == 0) +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; +x_227 = lean_ctor_get(x_5, 0); +x_228 = lean_ctor_get(x_5, 1); +x_229 = lean_array_uset(x_227, x_7, x_4); +lean_inc(x_225); +x_230 = lean_array_uset(x_228, x_7, x_225); +lean_ctor_set(x_5, 1, x_230); +lean_ctor_set(x_5, 0, x_229); +x_231 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_231, 0, x_225); +lean_ctor_set(x_231, 1, x_5); +return x_231; +} +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; +x_232 = lean_ctor_get(x_5, 0); +x_233 = lean_ctor_get(x_5, 1); +lean_inc(x_233); +lean_inc(x_232); lean_dec(x_5); -lean_inc(x_244); -x_247 = lean_array_uset(x_246, x_7, x_244); -x_248 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_248, 0, x_245); -lean_ctor_set(x_248, 1, x_247); -x_249 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_249, 0, x_244); -lean_ctor_set(x_249, 1, x_248); -return x_249; +x_234 = lean_array_uset(x_232, x_7, x_4); +lean_inc(x_225); +x_235 = lean_array_uset(x_233, x_7, x_225); +x_236 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_236, 0, x_234); +lean_ctor_set(x_236, 1, x_235); +x_237 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_237, 0, x_225); +lean_ctor_set(x_237, 1, x_236); +return x_237; +} } } else { -lean_object* x_250; -lean_dec(x_234); -x_250 = lean_box(0); -x_8 = x_250; -goto block_233; +lean_object* x_238; +x_238 = lean_box(0); +x_8 = x_238; +goto block_214; } } else { -lean_object* x_251; lean_object* x_252; lean_object* x_253; -lean_dec(x_234); +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_dec(x_4); lean_dec(x_2); -x_251 = lean_ctor_get(x_5, 1); -lean_inc(x_251); -x_252 = lean_array_uget(x_251, x_7); -lean_dec(x_251); -x_253 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_253, 0, x_252); -lean_ctor_set(x_253, 1, x_5); -return x_253; +x_239 = lean_ctor_get(x_5, 1); +lean_inc(x_239); +x_240 = lean_array_uget(x_239, x_7); +lean_dec(x_239); +x_241 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_241, 0, x_240); +lean_ctor_set(x_241, 1, x_5); +return x_241; } -block_233: +block_214: { lean_dec(x_8); switch (lean_obj_tag(x_4)) { @@ -1354,707 +1374,624 @@ 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_15, 0); x_18 = lean_ctor_get(x_15, 1); -x_19 = lean_ctor_get(x_18, 0); -lean_inc(x_19); -lean_inc(x_4); -x_20 = lean_array_uset(x_19, x_7, x_4); -x_21 = !lean_is_exclusive(x_4); +x_19 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_19, 0, x_9); +lean_ctor_set(x_19, 1, x_10); +lean_ctor_set_uint64(x_19, sizeof(void*)*2, x_11); +x_20 = lean_expr_update_app(x_19, x_13, x_17); +x_21 = !lean_is_exclusive(x_18); 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; -x_22 = lean_ctor_get(x_4, 1); -lean_dec(x_22); -x_23 = lean_ctor_get(x_4, 0); -lean_dec(x_23); -x_24 = lean_ctor_get(x_18, 1); -lean_inc(x_24); -lean_dec(x_18); -x_25 = lean_expr_update_app(x_4, x_13, x_17); -lean_inc(x_25); -x_26 = lean_array_uset(x_24, x_7, x_25); -x_27 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_27, 0, x_20); -lean_ctor_set(x_27, 1, x_26); -lean_ctor_set(x_15, 1, x_27); -lean_ctor_set(x_15, 0, x_25); +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_18, 0); +x_23 = lean_ctor_get(x_18, 1); +x_24 = lean_array_uset(x_22, x_7, x_4); +lean_inc(x_20); +x_25 = lean_array_uset(x_23, x_7, x_20); +lean_ctor_set(x_18, 1, x_25); +lean_ctor_set(x_18, 0, x_24); +lean_ctor_set(x_15, 0, x_20); return x_15; } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; -lean_dec(x_4); -x_28 = lean_ctor_get(x_18, 1); -lean_inc(x_28); +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_26 = lean_ctor_get(x_18, 0); +x_27 = lean_ctor_get(x_18, 1); +lean_inc(x_27); +lean_inc(x_26); lean_dec(x_18); -x_29 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_29, 0, x_9); -lean_ctor_set(x_29, 1, x_10); -lean_ctor_set_uint64(x_29, sizeof(void*)*2, x_11); -x_30 = lean_expr_update_app(x_29, x_13, x_17); -lean_inc(x_30); -x_31 = lean_array_uset(x_28, x_7, x_30); -x_32 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_32, 0, x_20); -lean_ctor_set(x_32, 1, x_31); -lean_ctor_set(x_15, 1, x_32); -lean_ctor_set(x_15, 0, x_30); +x_28 = lean_array_uset(x_26, x_7, x_4); +lean_inc(x_20); +x_29 = lean_array_uset(x_27, x_7, x_20); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +lean_ctor_set(x_15, 1, x_30); +lean_ctor_set(x_15, 0, x_20); return x_15; } } 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; 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_15, 0); -x_34 = lean_ctor_get(x_15, 1); -lean_inc(x_34); -lean_inc(x_33); +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_31 = lean_ctor_get(x_15, 0); +x_32 = lean_ctor_get(x_15, 1); +lean_inc(x_32); +lean_inc(x_31); lean_dec(x_15); -x_35 = lean_ctor_get(x_34, 0); +x_33 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_33, 0, x_9); +lean_ctor_set(x_33, 1, x_10); +lean_ctor_set_uint64(x_33, sizeof(void*)*2, x_11); +x_34 = lean_expr_update_app(x_33, x_13, x_31); +x_35 = lean_ctor_get(x_32, 0); lean_inc(x_35); -lean_inc(x_4); -x_36 = lean_array_uset(x_35, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - x_37 = x_4; +x_36 = lean_ctor_get(x_32, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_37 = x_32; } else { - lean_dec_ref(x_4); + lean_dec_ref(x_32); x_37 = lean_box(0); } -x_38 = lean_ctor_get(x_34, 1); -lean_inc(x_38); -lean_dec(x_34); +x_38 = lean_array_uset(x_35, x_7, x_4); +lean_inc(x_34); +x_39 = lean_array_uset(x_36, x_7, x_34); if (lean_is_scalar(x_37)) { - x_39 = lean_alloc_ctor(5, 2, 8); + x_40 = lean_alloc_ctor(0, 2, 0); } else { - x_39 = x_37; + x_40 = x_37; } -lean_ctor_set(x_39, 0, x_9); -lean_ctor_set(x_39, 1, x_10); -lean_ctor_set_uint64(x_39, sizeof(void*)*2, x_11); -x_40 = lean_expr_update_app(x_39, x_13, x_33); -lean_inc(x_40); -x_41 = lean_array_uset(x_38, x_7, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_36); -lean_ctor_set(x_42, 1, x_41); -x_43 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_43, 0, x_40); -lean_ctor_set(x_43, 1, x_42); -return x_43; +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_34); +lean_ctor_set(x_41, 1, x_40); +return x_41; } } case 6: { -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_object* x_50; lean_object* x_51; uint8_t x_52; -x_44 = lean_ctor_get(x_4, 0); +lean_object* x_42; lean_object* x_43; lean_object* x_44; uint64_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_42 = lean_ctor_get(x_4, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_4, 1); +lean_inc(x_43); +x_44 = lean_ctor_get(x_4, 2); lean_inc(x_44); -x_45 = lean_ctor_get(x_4, 1); -lean_inc(x_45); -x_46 = lean_ctor_get(x_4, 2); -lean_inc(x_46); -x_47 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_45); +x_45 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_43); lean_inc(x_2); -x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_45, x_5); -x_49 = lean_ctor_get(x_48, 0); -lean_inc(x_49); -x_50 = lean_ctor_get(x_48, 1); -lean_inc(x_50); -lean_dec(x_48); -lean_inc(x_46); -x_51 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_46, x_50); -x_52 = !lean_is_exclusive(x_51); -if (x_52 == 0) +x_46 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_43, x_5); +x_47 = lean_ctor_get(x_46, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_46, 1); +lean_inc(x_48); +lean_dec(x_46); +lean_inc(x_44); +x_49 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_44, x_48); +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; -x_53 = lean_ctor_get(x_51, 0); -x_54 = lean_ctor_get(x_51, 1); -x_55 = lean_ctor_get(x_54, 0); +lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; uint8_t x_56; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +x_53 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_53, 0, x_42); +lean_ctor_set(x_53, 1, x_43); +lean_ctor_set(x_53, 2, x_44); +lean_ctor_set_uint64(x_53, sizeof(void*)*3, x_45); +x_54 = (uint8_t)((x_45 << 24) >> 61); +x_55 = lean_expr_update_lambda(x_53, x_54, x_47, x_51); +x_56 = !lean_is_exclusive(x_52); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_57 = lean_ctor_get(x_52, 0); +x_58 = lean_ctor_get(x_52, 1); +x_59 = lean_array_uset(x_57, x_7, x_4); lean_inc(x_55); -lean_inc(x_4); -x_56 = lean_array_uset(x_55, x_7, x_4); -x_57 = !lean_is_exclusive(x_4); -if (x_57 == 0) +x_60 = lean_array_uset(x_58, x_7, x_55); +lean_ctor_set(x_52, 1, x_60); +lean_ctor_set(x_52, 0, x_59); +lean_ctor_set(x_49, 0, x_55); +return x_49; +} +else { -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_58 = lean_ctor_get(x_4, 2); -lean_dec(x_58); -x_59 = lean_ctor_get(x_4, 1); -lean_dec(x_59); -x_60 = lean_ctor_get(x_4, 0); -lean_dec(x_60); -x_61 = lean_ctor_get(x_54, 1); +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_52, 0); +x_62 = lean_ctor_get(x_52, 1); +lean_inc(x_62); lean_inc(x_61); -lean_dec(x_54); -x_62 = (uint8_t)((x_47 << 24) >> 61); -x_63 = lean_expr_update_lambda(x_4, x_62, x_49, x_53); -lean_inc(x_63); -x_64 = lean_array_uset(x_61, x_7, x_63); +lean_dec(x_52); +x_63 = lean_array_uset(x_61, x_7, x_4); +lean_inc(x_55); +x_64 = lean_array_uset(x_62, x_7, x_55); x_65 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_65, 0, x_56); +lean_ctor_set(x_65, 0, x_63); lean_ctor_set(x_65, 1, x_64); -lean_ctor_set(x_51, 1, x_65); -lean_ctor_set(x_51, 0, x_63); -return x_51; +lean_ctor_set(x_49, 1, x_65); +lean_ctor_set(x_49, 0, x_55); +return x_49; +} } else { -lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; -lean_dec(x_4); -x_66 = lean_ctor_get(x_54, 1); +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; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_66 = lean_ctor_get(x_49, 0); +x_67 = lean_ctor_get(x_49, 1); +lean_inc(x_67); lean_inc(x_66); -lean_dec(x_54); -x_67 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_67, 0, x_44); -lean_ctor_set(x_67, 1, x_45); -lean_ctor_set(x_67, 2, x_46); -lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_47); -x_68 = (uint8_t)((x_47 << 24) >> 61); -x_69 = lean_expr_update_lambda(x_67, x_68, x_49, x_53); -lean_inc(x_69); -x_70 = lean_array_uset(x_66, x_7, x_69); -x_71 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_71, 0, x_56); -lean_ctor_set(x_71, 1, x_70); -lean_ctor_set(x_51, 1, x_71); -lean_ctor_set(x_51, 0, x_69); -return x_51; -} -} -else -{ -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_72 = lean_ctor_get(x_51, 0); -x_73 = lean_ctor_get(x_51, 1); -lean_inc(x_73); +lean_dec(x_49); +x_68 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_68, 0, x_42); +lean_ctor_set(x_68, 1, x_43); +lean_ctor_set(x_68, 2, x_44); +lean_ctor_set_uint64(x_68, sizeof(void*)*3, x_45); +x_69 = (uint8_t)((x_45 << 24) >> 61); +x_70 = lean_expr_update_lambda(x_68, x_69, x_47, x_66); +x_71 = lean_ctor_get(x_67, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_67, 1); lean_inc(x_72); -lean_dec(x_51); -x_74 = lean_ctor_get(x_73, 0); -lean_inc(x_74); -lean_inc(x_4); -x_75 = lean_array_uset(x_74, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_76 = x_4; +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_73 = x_67; } else { - lean_dec_ref(x_4); - x_76 = lean_box(0); + lean_dec_ref(x_67); + x_73 = lean_box(0); } -x_77 = lean_ctor_get(x_73, 1); -lean_inc(x_77); -lean_dec(x_73); -if (lean_is_scalar(x_76)) { - x_78 = lean_alloc_ctor(6, 3, 8); +x_74 = lean_array_uset(x_71, x_7, x_4); +lean_inc(x_70); +x_75 = lean_array_uset(x_72, x_7, x_70); +if (lean_is_scalar(x_73)) { + x_76 = lean_alloc_ctor(0, 2, 0); } else { - x_78 = x_76; + x_76 = x_73; } -lean_ctor_set(x_78, 0, x_44); -lean_ctor_set(x_78, 1, x_45); -lean_ctor_set(x_78, 2, x_46); -lean_ctor_set_uint64(x_78, sizeof(void*)*3, x_47); -x_79 = (uint8_t)((x_47 << 24) >> 61); -x_80 = lean_expr_update_lambda(x_78, x_79, x_49, x_72); -lean_inc(x_80); -x_81 = lean_array_uset(x_77, x_7, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_75); -lean_ctor_set(x_82, 1, x_81); -x_83 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_83, 0, x_80); -lean_ctor_set(x_83, 1, x_82); -return x_83; +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_70); +lean_ctor_set(x_77, 1, x_76); +return x_77; } } case 7: { -lean_object* x_84; lean_object* x_85; lean_object* x_86; uint64_t x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; uint8_t x_92; -x_84 = lean_ctor_get(x_4, 0); -lean_inc(x_84); -x_85 = lean_ctor_get(x_4, 1); -lean_inc(x_85); -x_86 = lean_ctor_get(x_4, 2); -lean_inc(x_86); -x_87 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_85); +lean_object* x_78; lean_object* x_79; lean_object* x_80; uint64_t x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; +x_78 = lean_ctor_get(x_4, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_4, 1); +lean_inc(x_79); +x_80 = lean_ctor_get(x_4, 2); +lean_inc(x_80); +x_81 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_79); lean_inc(x_2); -x_88 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_85, x_5); -x_89 = lean_ctor_get(x_88, 0); -lean_inc(x_89); -x_90 = lean_ctor_get(x_88, 1); -lean_inc(x_90); -lean_dec(x_88); -lean_inc(x_86); -x_91 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_86, x_90); -x_92 = !lean_is_exclusive(x_91); +x_82 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_79, x_5); +x_83 = lean_ctor_get(x_82, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_82, 1); +lean_inc(x_84); +lean_dec(x_82); +lean_inc(x_80); +x_85 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_80, x_84); +x_86 = !lean_is_exclusive(x_85); +if (x_86 == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; uint8_t x_92; +x_87 = lean_ctor_get(x_85, 0); +x_88 = lean_ctor_get(x_85, 1); +x_89 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_89, 0, x_78); +lean_ctor_set(x_89, 1, x_79); +lean_ctor_set(x_89, 2, x_80); +lean_ctor_set_uint64(x_89, sizeof(void*)*3, x_81); +x_90 = (uint8_t)((x_81 << 24) >> 61); +x_91 = lean_expr_update_forall(x_89, x_90, x_83, x_87); +x_92 = !lean_is_exclusive(x_88); if (x_92 == 0) { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; uint8_t x_97; -x_93 = lean_ctor_get(x_91, 0); -x_94 = lean_ctor_get(x_91, 1); -x_95 = lean_ctor_get(x_94, 0); -lean_inc(x_95); -lean_inc(x_4); -x_96 = lean_array_uset(x_95, x_7, x_4); -x_97 = !lean_is_exclusive(x_4); -if (x_97 == 0) +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_93 = lean_ctor_get(x_88, 0); +x_94 = lean_ctor_get(x_88, 1); +x_95 = lean_array_uset(x_93, x_7, x_4); +lean_inc(x_91); +x_96 = lean_array_uset(x_94, x_7, x_91); +lean_ctor_set(x_88, 1, x_96); +lean_ctor_set(x_88, 0, x_95); +lean_ctor_set(x_85, 0, x_91); +return x_85; +} +else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; -x_98 = lean_ctor_get(x_4, 2); -lean_dec(x_98); -x_99 = lean_ctor_get(x_4, 1); -lean_dec(x_99); -x_100 = lean_ctor_get(x_4, 0); -lean_dec(x_100); -x_101 = lean_ctor_get(x_94, 1); -lean_inc(x_101); -lean_dec(x_94); -x_102 = (uint8_t)((x_87 << 24) >> 61); -x_103 = lean_expr_update_forall(x_4, x_102, x_89, x_93); +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_88, 0); +x_98 = lean_ctor_get(x_88, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_88); +x_99 = lean_array_uset(x_97, x_7, x_4); +lean_inc(x_91); +x_100 = lean_array_uset(x_98, x_7, x_91); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_85, 1, x_101); +lean_ctor_set(x_85, 0, x_91); +return x_85; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t 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; +x_102 = lean_ctor_get(x_85, 0); +x_103 = lean_ctor_get(x_85, 1); lean_inc(x_103); -x_104 = lean_array_uset(x_101, x_7, x_103); -x_105 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_105, 0, x_96); -lean_ctor_set(x_105, 1, x_104); -lean_ctor_set(x_91, 1, x_105); -lean_ctor_set(x_91, 0, x_103); -return x_91; +lean_inc(x_102); +lean_dec(x_85); +x_104 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_104, 0, x_78); +lean_ctor_set(x_104, 1, x_79); +lean_ctor_set(x_104, 2, x_80); +lean_ctor_set_uint64(x_104, sizeof(void*)*3, x_81); +x_105 = (uint8_t)((x_81 << 24) >> 61); +x_106 = lean_expr_update_forall(x_104, x_105, x_83, x_102); +x_107 = lean_ctor_get(x_103, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_103, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); + x_109 = x_103; +} else { + lean_dec_ref(x_103); + x_109 = lean_box(0); } -else -{ -lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; -lean_dec(x_4); -x_106 = lean_ctor_get(x_94, 1); +x_110 = lean_array_uset(x_107, x_7, x_4); lean_inc(x_106); -lean_dec(x_94); -x_107 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_107, 0, x_84); -lean_ctor_set(x_107, 1, x_85); -lean_ctor_set(x_107, 2, x_86); -lean_ctor_set_uint64(x_107, sizeof(void*)*3, x_87); -x_108 = (uint8_t)((x_87 << 24) >> 61); -x_109 = lean_expr_update_forall(x_107, x_108, x_89, x_93); -lean_inc(x_109); -x_110 = lean_array_uset(x_106, x_7, x_109); -x_111 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_111, 0, x_96); -lean_ctor_set(x_111, 1, x_110); -lean_ctor_set(x_91, 1, x_111); -lean_ctor_set(x_91, 0, x_109); -return x_91; -} -} -else -{ -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; lean_object* x_121; lean_object* x_122; lean_object* x_123; -x_112 = lean_ctor_get(x_91, 0); -x_113 = lean_ctor_get(x_91, 1); -lean_inc(x_113); -lean_inc(x_112); -lean_dec(x_91); -x_114 = lean_ctor_get(x_113, 0); -lean_inc(x_114); -lean_inc(x_4); -x_115 = lean_array_uset(x_114, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_116 = x_4; +x_111 = lean_array_uset(x_108, x_7, x_106); +if (lean_is_scalar(x_109)) { + x_112 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_4); - x_116 = lean_box(0); + x_112 = x_109; } -x_117 = lean_ctor_get(x_113, 1); -lean_inc(x_117); -lean_dec(x_113); -if (lean_is_scalar(x_116)) { - x_118 = lean_alloc_ctor(7, 3, 8); -} else { - x_118 = x_116; -} -lean_ctor_set(x_118, 0, x_84); -lean_ctor_set(x_118, 1, x_85); -lean_ctor_set(x_118, 2, x_86); -lean_ctor_set_uint64(x_118, sizeof(void*)*3, x_87); -x_119 = (uint8_t)((x_87 << 24) >> 61); -x_120 = lean_expr_update_forall(x_118, x_119, x_89, x_112); -lean_inc(x_120); -x_121 = lean_array_uset(x_117, x_7, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_115); -lean_ctor_set(x_122, 1, x_121); -x_123 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_123, 0, x_120); -lean_ctor_set(x_123, 1, x_122); -return x_123; +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_106); +lean_ctor_set(x_113, 1, x_112); +return x_113; } } case 8: { -lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint64_t 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; uint8_t x_136; -x_124 = lean_ctor_get(x_4, 0); +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint64_t 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; +x_114 = lean_ctor_get(x_4, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_4, 1); +lean_inc(x_115); +x_116 = lean_ctor_get(x_4, 2); +lean_inc(x_116); +x_117 = lean_ctor_get(x_4, 3); +lean_inc(x_117); +x_118 = lean_ctor_get_uint64(x_4, sizeof(void*)*4); +lean_inc(x_115); +lean_inc(x_2); +x_119 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_115, x_5); +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +lean_inc(x_116); +lean_inc(x_2); +x_122 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_116, x_121); +x_123 = lean_ctor_get(x_122, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_122, 1); lean_inc(x_124); -x_125 = lean_ctor_get(x_4, 1); -lean_inc(x_125); -x_126 = lean_ctor_get(x_4, 2); -lean_inc(x_126); -x_127 = lean_ctor_get(x_4, 3); -lean_inc(x_127); -x_128 = lean_ctor_get_uint64(x_4, sizeof(void*)*4); -lean_inc(x_125); -lean_inc(x_2); -x_129 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_125, x_5); -x_130 = lean_ctor_get(x_129, 0); +lean_dec(x_122); +lean_inc(x_117); +x_125 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_117, x_124); +x_126 = !lean_is_exclusive(x_125); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; +x_127 = lean_ctor_get(x_125, 0); +x_128 = lean_ctor_get(x_125, 1); +x_129 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_129, 0, x_114); +lean_ctor_set(x_129, 1, x_115); +lean_ctor_set(x_129, 2, x_116); +lean_ctor_set(x_129, 3, x_117); +lean_ctor_set_uint64(x_129, sizeof(void*)*4, x_118); +x_130 = lean_expr_update_let(x_129, x_120, x_123, x_127); +x_131 = !lean_is_exclusive(x_128); +if (x_131 == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_132 = lean_ctor_get(x_128, 0); +x_133 = lean_ctor_get(x_128, 1); +x_134 = lean_array_uset(x_132, x_7, x_4); lean_inc(x_130); -x_131 = lean_ctor_get(x_129, 1); -lean_inc(x_131); -lean_dec(x_129); -lean_inc(x_126); -lean_inc(x_2); -x_132 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_126, x_131); -x_133 = lean_ctor_get(x_132, 0); -lean_inc(x_133); -x_134 = lean_ctor_get(x_132, 1); -lean_inc(x_134); -lean_dec(x_132); -lean_inc(x_127); -x_135 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_127, x_134); -x_136 = !lean_is_exclusive(x_135); -if (x_136 == 0) +x_135 = lean_array_uset(x_133, x_7, x_130); +lean_ctor_set(x_128, 1, x_135); +lean_ctor_set(x_128, 0, x_134); +lean_ctor_set(x_125, 0, x_130); +return x_125; +} +else { -lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; uint8_t x_141; -x_137 = lean_ctor_get(x_135, 0); -x_138 = lean_ctor_get(x_135, 1); -x_139 = lean_ctor_get(x_138, 0); -lean_inc(x_139); -lean_inc(x_4); -x_140 = lean_array_uset(x_139, x_7, x_4); -x_141 = !lean_is_exclusive(x_4); -if (x_141 == 0) +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_128, 0); +x_137 = lean_ctor_get(x_128, 1); +lean_inc(x_137); +lean_inc(x_136); +lean_dec(x_128); +x_138 = lean_array_uset(x_136, x_7, x_4); +lean_inc(x_130); +x_139 = lean_array_uset(x_137, x_7, x_130); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_138); +lean_ctor_set(x_140, 1, x_139); +lean_ctor_set(x_125, 1, x_140); +lean_ctor_set(x_125, 0, x_130); +return x_125; +} +} +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; -x_142 = lean_ctor_get(x_4, 3); -lean_dec(x_142); -x_143 = lean_ctor_get(x_4, 2); -lean_dec(x_143); -x_144 = lean_ctor_get(x_4, 1); -lean_dec(x_144); -x_145 = lean_ctor_get(x_4, 0); -lean_dec(x_145); -x_146 = lean_ctor_get(x_138, 1); +lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_141 = lean_ctor_get(x_125, 0); +x_142 = lean_ctor_get(x_125, 1); +lean_inc(x_142); +lean_inc(x_141); +lean_dec(x_125); +x_143 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_143, 0, x_114); +lean_ctor_set(x_143, 1, x_115); +lean_ctor_set(x_143, 2, x_116); +lean_ctor_set(x_143, 3, x_117); +lean_ctor_set_uint64(x_143, sizeof(void*)*4, x_118); +x_144 = lean_expr_update_let(x_143, x_120, x_123, x_141); +x_145 = lean_ctor_get(x_142, 0); +lean_inc(x_145); +x_146 = lean_ctor_get(x_142, 1); lean_inc(x_146); -lean_dec(x_138); -x_147 = lean_expr_update_let(x_4, x_130, x_133, x_137); -lean_inc(x_147); -x_148 = lean_array_uset(x_146, x_7, x_147); -x_149 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_149, 0, x_140); -lean_ctor_set(x_149, 1, x_148); -lean_ctor_set(x_135, 1, x_149); -lean_ctor_set(x_135, 0, x_147); -return x_135; -} -else -{ -lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; -lean_dec(x_4); -x_150 = lean_ctor_get(x_138, 1); -lean_inc(x_150); -lean_dec(x_138); -x_151 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_151, 0, x_124); -lean_ctor_set(x_151, 1, x_125); -lean_ctor_set(x_151, 2, x_126); -lean_ctor_set(x_151, 3, x_127); -lean_ctor_set_uint64(x_151, sizeof(void*)*4, x_128); -x_152 = lean_expr_update_let(x_151, x_130, x_133, x_137); -lean_inc(x_152); -x_153 = lean_array_uset(x_150, x_7, x_152); -x_154 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_154, 0, x_140); -lean_ctor_set(x_154, 1, x_153); -lean_ctor_set(x_135, 1, x_154); -lean_ctor_set(x_135, 0, x_152); -return x_135; -} -} -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; lean_object* x_164; lean_object* x_165; -x_155 = lean_ctor_get(x_135, 0); -x_156 = lean_ctor_get(x_135, 1); -lean_inc(x_156); -lean_inc(x_155); -lean_dec(x_135); -x_157 = lean_ctor_get(x_156, 0); -lean_inc(x_157); -lean_inc(x_4); -x_158 = lean_array_uset(x_157, x_7, x_4); -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_159 = x_4; +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_4); - x_159 = lean_box(0); + lean_dec_ref(x_142); + x_147 = lean_box(0); } -x_160 = lean_ctor_get(x_156, 1); -lean_inc(x_160); -lean_dec(x_156); -if (lean_is_scalar(x_159)) { - x_161 = lean_alloc_ctor(8, 4, 8); +x_148 = lean_array_uset(x_145, x_7, x_4); +lean_inc(x_144); +x_149 = lean_array_uset(x_146, x_7, x_144); +if (lean_is_scalar(x_147)) { + x_150 = lean_alloc_ctor(0, 2, 0); } else { - x_161 = x_159; + x_150 = x_147; } -lean_ctor_set(x_161, 0, x_124); -lean_ctor_set(x_161, 1, x_125); -lean_ctor_set(x_161, 2, x_126); -lean_ctor_set(x_161, 3, x_127); -lean_ctor_set_uint64(x_161, sizeof(void*)*4, x_128); -x_162 = lean_expr_update_let(x_161, x_130, x_133, x_155); -lean_inc(x_162); -x_163 = lean_array_uset(x_160, x_7, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_158); -lean_ctor_set(x_164, 1, x_163); -x_165 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_165, 0, x_162); -lean_ctor_set(x_165, 1, x_164); -return x_165; +lean_ctor_set(x_150, 0, x_148); +lean_ctor_set(x_150, 1, x_149); +x_151 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_151, 0, x_144); +lean_ctor_set(x_151, 1, x_150); +return x_151; } } case 10: { -lean_object* x_166; lean_object* x_167; uint64_t x_168; lean_object* x_169; uint8_t x_170; -x_166 = lean_ctor_get(x_4, 0); +lean_object* x_152; lean_object* x_153; uint64_t x_154; lean_object* x_155; uint8_t x_156; +x_152 = lean_ctor_get(x_4, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_4, 1); +lean_inc(x_153); +x_154 = lean_ctor_get_uint64(x_4, sizeof(void*)*2); +lean_inc(x_153); +x_155 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_153, x_5); +x_156 = !lean_is_exclusive(x_155); +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_155, 0); +x_158 = lean_ctor_get(x_155, 1); +x_159 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_159, 0, x_152); +lean_ctor_set(x_159, 1, x_153); +lean_ctor_set_uint64(x_159, sizeof(void*)*2, x_154); +x_160 = lean_expr_update_mdata(x_159, x_157); +x_161 = !lean_is_exclusive(x_158); +if (x_161 == 0) +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_162 = lean_ctor_get(x_158, 0); +x_163 = lean_ctor_get(x_158, 1); +x_164 = lean_array_uset(x_162, x_7, x_4); +lean_inc(x_160); +x_165 = lean_array_uset(x_163, x_7, x_160); +lean_ctor_set(x_158, 1, x_165); +lean_ctor_set(x_158, 0, x_164); +lean_ctor_set(x_155, 0, x_160); +return x_155; +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_166 = lean_ctor_get(x_158, 0); +x_167 = lean_ctor_get(x_158, 1); +lean_inc(x_167); lean_inc(x_166); -x_167 = lean_ctor_get(x_4, 1); -lean_inc(x_167); -x_168 = lean_ctor_get_uint64(x_4, sizeof(void*)*2); -lean_inc(x_167); -x_169 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_167, x_5); -x_170 = !lean_is_exclusive(x_169); -if (x_170 == 0) +lean_dec(x_158); +x_168 = lean_array_uset(x_166, x_7, x_4); +lean_inc(x_160); +x_169 = lean_array_uset(x_167, x_7, x_160); +x_170 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_170, 0, x_168); +lean_ctor_set(x_170, 1, x_169); +lean_ctor_set(x_155, 1, x_170); +lean_ctor_set(x_155, 0, x_160); +return x_155; +} +} +else { -lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; -x_171 = lean_ctor_get(x_169, 0); -x_172 = lean_ctor_get(x_169, 1); -x_173 = lean_ctor_get(x_172, 0); -lean_inc(x_173); -lean_inc(x_4); -x_174 = lean_array_uset(x_173, x_7, x_4); -x_175 = !lean_is_exclusive(x_4); -if (x_175 == 0) -{ -lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; -x_176 = lean_ctor_get(x_4, 1); -lean_dec(x_176); -x_177 = lean_ctor_get(x_4, 0); -lean_dec(x_177); -x_178 = lean_ctor_get(x_172, 1); -lean_inc(x_178); -lean_dec(x_172); -x_179 = lean_expr_update_mdata(x_4, x_171); -lean_inc(x_179); -x_180 = lean_array_uset(x_178, x_7, x_179); +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_171 = lean_ctor_get(x_155, 0); +x_172 = lean_ctor_get(x_155, 1); +lean_inc(x_172); +lean_inc(x_171); +lean_dec(x_155); +x_173 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_173, 0, x_152); +lean_ctor_set(x_173, 1, x_153); +lean_ctor_set_uint64(x_173, sizeof(void*)*2, x_154); +x_174 = lean_expr_update_mdata(x_173, x_171); +x_175 = lean_ctor_get(x_172, 0); +lean_inc(x_175); +x_176 = lean_ctor_get(x_172, 1); +lean_inc(x_176); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_177 = x_172; +} else { + lean_dec_ref(x_172); + x_177 = lean_box(0); +} +x_178 = lean_array_uset(x_175, x_7, x_4); +lean_inc(x_174); +x_179 = lean_array_uset(x_176, x_7, x_174); +if (lean_is_scalar(x_177)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_177; +} +lean_ctor_set(x_180, 0, x_178); +lean_ctor_set(x_180, 1, x_179); x_181 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_181, 0, x_174); lean_ctor_set(x_181, 1, x_180); -lean_ctor_set(x_169, 1, x_181); -lean_ctor_set(x_169, 0, x_179); -return x_169; -} -else -{ -lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; -lean_dec(x_4); -x_182 = lean_ctor_get(x_172, 1); -lean_inc(x_182); -lean_dec(x_172); -x_183 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_183, 0, x_166); -lean_ctor_set(x_183, 1, x_167); -lean_ctor_set_uint64(x_183, sizeof(void*)*2, x_168); -x_184 = lean_expr_update_mdata(x_183, x_171); -lean_inc(x_184); -x_185 = lean_array_uset(x_182, x_7, x_184); -x_186 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_186, 0, x_174); -lean_ctor_set(x_186, 1, x_185); -lean_ctor_set(x_169, 1, x_186); -lean_ctor_set(x_169, 0, x_184); -return x_169; -} -} -else -{ -lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; -x_187 = lean_ctor_get(x_169, 0); -x_188 = lean_ctor_get(x_169, 1); -lean_inc(x_188); -lean_inc(x_187); -lean_dec(x_169); -x_189 = lean_ctor_get(x_188, 0); -lean_inc(x_189); -lean_inc(x_4); -x_190 = lean_array_uset(x_189, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - x_191 = x_4; -} else { - lean_dec_ref(x_4); - x_191 = lean_box(0); -} -x_192 = lean_ctor_get(x_188, 1); -lean_inc(x_192); -lean_dec(x_188); -if (lean_is_scalar(x_191)) { - x_193 = lean_alloc_ctor(10, 2, 8); -} else { - x_193 = x_191; -} -lean_ctor_set(x_193, 0, x_166); -lean_ctor_set(x_193, 1, x_167); -lean_ctor_set_uint64(x_193, sizeof(void*)*2, x_168); -x_194 = lean_expr_update_mdata(x_193, x_187); -lean_inc(x_194); -x_195 = lean_array_uset(x_192, x_7, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_190); -lean_ctor_set(x_196, 1, x_195); -x_197 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_197, 0, x_194); -lean_ctor_set(x_197, 1, x_196); -return x_197; +return x_181; } } case 11: { -lean_object* x_198; lean_object* x_199; lean_object* x_200; uint64_t x_201; lean_object* x_202; uint8_t x_203; -x_198 = lean_ctor_get(x_4, 0); +lean_object* x_182; lean_object* x_183; lean_object* x_184; uint64_t x_185; lean_object* x_186; uint8_t x_187; +x_182 = lean_ctor_get(x_4, 0); +lean_inc(x_182); +x_183 = lean_ctor_get(x_4, 1); +lean_inc(x_183); +x_184 = lean_ctor_get(x_4, 2); +lean_inc(x_184); +x_185 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_184); +x_186 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_184, x_5); +x_187 = !lean_is_exclusive(x_186); +if (x_187 == 0) +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; uint8_t x_192; +x_188 = lean_ctor_get(x_186, 0); +x_189 = lean_ctor_get(x_186, 1); +x_190 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_190, 0, x_182); +lean_ctor_set(x_190, 1, x_183); +lean_ctor_set(x_190, 2, x_184); +lean_ctor_set_uint64(x_190, sizeof(void*)*3, x_185); +x_191 = lean_expr_update_proj(x_190, x_188); +x_192 = !lean_is_exclusive(x_189); +if (x_192 == 0) +{ +lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; +x_193 = lean_ctor_get(x_189, 0); +x_194 = lean_ctor_get(x_189, 1); +x_195 = lean_array_uset(x_193, x_7, x_4); +lean_inc(x_191); +x_196 = lean_array_uset(x_194, x_7, x_191); +lean_ctor_set(x_189, 1, x_196); +lean_ctor_set(x_189, 0, x_195); +lean_ctor_set(x_186, 0, x_191); +return x_186; +} +else +{ +lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; +x_197 = lean_ctor_get(x_189, 0); +x_198 = lean_ctor_get(x_189, 1); lean_inc(x_198); -x_199 = lean_ctor_get(x_4, 1); -lean_inc(x_199); -x_200 = lean_ctor_get(x_4, 2); -lean_inc(x_200); -x_201 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_200); -x_202 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1(x_1, x_2, x_3, x_200, x_5); -x_203 = !lean_is_exclusive(x_202); -if (x_203 == 0) +lean_inc(x_197); +lean_dec(x_189); +x_199 = lean_array_uset(x_197, x_7, x_4); +lean_inc(x_191); +x_200 = lean_array_uset(x_198, x_7, x_191); +x_201 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_201, 0, x_199); +lean_ctor_set(x_201, 1, x_200); +lean_ctor_set(x_186, 1, x_201); +lean_ctor_set(x_186, 0, x_191); +return x_186; +} +} +else { -lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; uint8_t x_208; -x_204 = lean_ctor_get(x_202, 0); -x_205 = lean_ctor_get(x_202, 1); -x_206 = lean_ctor_get(x_205, 0); +lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; +x_202 = lean_ctor_get(x_186, 0); +x_203 = lean_ctor_get(x_186, 1); +lean_inc(x_203); +lean_inc(x_202); +lean_dec(x_186); +x_204 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_204, 0, x_182); +lean_ctor_set(x_204, 1, x_183); +lean_ctor_set(x_204, 2, x_184); +lean_ctor_set_uint64(x_204, sizeof(void*)*3, x_185); +x_205 = lean_expr_update_proj(x_204, x_202); +x_206 = lean_ctor_get(x_203, 0); lean_inc(x_206); -lean_inc(x_4); -x_207 = lean_array_uset(x_206, x_7, x_4); -x_208 = !lean_is_exclusive(x_4); -if (x_208 == 0) -{ -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; -x_209 = lean_ctor_get(x_4, 2); -lean_dec(x_209); -x_210 = lean_ctor_get(x_4, 1); -lean_dec(x_210); -x_211 = lean_ctor_get(x_4, 0); -lean_dec(x_211); -x_212 = lean_ctor_get(x_205, 1); -lean_inc(x_212); -lean_dec(x_205); -x_213 = lean_expr_update_proj(x_4, x_204); -lean_inc(x_213); -x_214 = lean_array_uset(x_212, x_7, x_213); -x_215 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_215, 0, x_207); -lean_ctor_set(x_215, 1, x_214); -lean_ctor_set(x_202, 1, x_215); -lean_ctor_set(x_202, 0, x_213); -return x_202; -} -else -{ -lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; -lean_dec(x_4); -x_216 = lean_ctor_get(x_205, 1); -lean_inc(x_216); -lean_dec(x_205); -x_217 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_217, 0, x_198); -lean_ctor_set(x_217, 1, x_199); -lean_ctor_set(x_217, 2, x_200); -lean_ctor_set_uint64(x_217, sizeof(void*)*3, x_201); -x_218 = lean_expr_update_proj(x_217, x_204); -lean_inc(x_218); -x_219 = lean_array_uset(x_216, x_7, x_218); -x_220 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_220, 0, x_207); -lean_ctor_set(x_220, 1, x_219); -lean_ctor_set(x_202, 1, x_220); -lean_ctor_set(x_202, 0, x_218); -return x_202; -} -} -else -{ -lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; -x_221 = lean_ctor_get(x_202, 0); -x_222 = lean_ctor_get(x_202, 1); -lean_inc(x_222); -lean_inc(x_221); -lean_dec(x_202); -x_223 = lean_ctor_get(x_222, 0); -lean_inc(x_223); -lean_inc(x_4); -x_224 = lean_array_uset(x_223, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_225 = x_4; +x_207 = lean_ctor_get(x_203, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_203)) { + lean_ctor_release(x_203, 0); + lean_ctor_release(x_203, 1); + x_208 = x_203; } else { - lean_dec_ref(x_4); - x_225 = lean_box(0); + lean_dec_ref(x_203); + x_208 = lean_box(0); } -x_226 = lean_ctor_get(x_222, 1); -lean_inc(x_226); -lean_dec(x_222); -if (lean_is_scalar(x_225)) { - x_227 = lean_alloc_ctor(11, 3, 8); +x_209 = lean_array_uset(x_206, x_7, x_4); +lean_inc(x_205); +x_210 = lean_array_uset(x_207, x_7, x_205); +if (lean_is_scalar(x_208)) { + x_211 = lean_alloc_ctor(0, 2, 0); } else { - x_227 = x_225; + x_211 = x_208; } -lean_ctor_set(x_227, 0, x_198); -lean_ctor_set(x_227, 1, x_199); -lean_ctor_set(x_227, 2, x_200); -lean_ctor_set_uint64(x_227, sizeof(void*)*3, x_201); -x_228 = lean_expr_update_proj(x_227, x_221); -lean_inc(x_228); -x_229 = lean_array_uset(x_226, x_7, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_224); -lean_ctor_set(x_230, 1, x_229); -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_228); -lean_ctor_set(x_231, 1, x_230); -return x_231; +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_205); +lean_ctor_set(x_212, 1, x_211); +return x_212; } } default: { -lean_object* x_232; +lean_object* x_213; lean_dec(x_2); -x_232 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_232, 0, x_4); -lean_ctor_set(x_232, 1, x_5); -return x_232; +x_213 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_213, 0, x_4); +lean_ctor_set(x_213, 1, x_5); +return x_213; } } } @@ -2063,82 +2000,102 @@ return x_232; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(lean_object* x_1, lean_object* x_2, size_t x_3, lean_object* x_4, lean_object* x_5) { _start: { -size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_234; lean_object* x_235; size_t x_236; uint8_t x_237; +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_215; lean_object* x_216; size_t x_217; uint8_t x_218; x_6 = lean_ptr_addr(x_4); x_7 = x_3 == 0 ? x_6 : x_6 % x_3; -x_234 = lean_ctor_get(x_5, 0); -lean_inc(x_234); -x_235 = lean_array_uget(x_234, x_7); -x_236 = lean_ptr_addr(x_235); -lean_dec(x_235); -x_237 = x_236 == x_6; -if (x_237 == 0) +x_215 = lean_ctor_get(x_5, 0); +lean_inc(x_215); +x_216 = lean_array_uget(x_215, x_7); +lean_dec(x_215); +x_217 = lean_ptr_addr(x_216); +lean_dec(x_216); +x_218 = x_217 == x_6; +if (x_218 == 0) { if (lean_obj_tag(x_4) == 4) { -lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; uint8_t x_242; -x_238 = lean_ctor_get(x_4, 0); -lean_inc(x_238); -lean_inc(x_238); -x_239 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1___lambda__1___boxed), 2, 1); -lean_closure_set(x_239, 0, x_238); -x_240 = lean_array_get_size(x_1); -x_241 = lean_unsigned_to_nat(0u); -x_242 = l_Array_anyMUnsafe___at_Array_any___spec__1___rarg(x_239, x_1, x_241, x_240); -lean_dec(x_240); -if (x_242 == 0) +lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; uint8_t x_223; +x_219 = lean_ctor_get(x_4, 0); +lean_inc(x_219); +lean_inc(x_219); +x_220 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1___lambda__1___boxed), 2, 1); +lean_closure_set(x_220, 0, x_219); +x_221 = lean_array_get_size(x_1); +x_222 = lean_unsigned_to_nat(0u); +x_223 = l_Array_anyMUnsafe___at_Array_any___spec__1___rarg(x_220, x_1, x_222, x_221); +lean_dec(x_221); +if (x_223 == 0) { -lean_object* x_243; -lean_dec(x_238); -lean_dec(x_234); -x_243 = lean_box(0); -x_8 = x_243; -goto block_233; +lean_object* x_224; +lean_dec(x_219); +x_224 = lean_box(0); +x_8 = x_224; +goto block_214; } else { -lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; -x_244 = l_Lean_mkConst(x_238, x_2); -x_245 = lean_array_uset(x_234, x_7, x_4); -x_246 = lean_ctor_get(x_5, 1); -lean_inc(x_246); +lean_object* x_225; uint8_t x_226; +x_225 = l_Lean_mkConst(x_219, x_2); +x_226 = !lean_is_exclusive(x_5); +if (x_226 == 0) +{ +lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; +x_227 = lean_ctor_get(x_5, 0); +x_228 = lean_ctor_get(x_5, 1); +x_229 = lean_array_uset(x_227, x_7, x_4); +lean_inc(x_225); +x_230 = lean_array_uset(x_228, x_7, x_225); +lean_ctor_set(x_5, 1, x_230); +lean_ctor_set(x_5, 0, x_229); +x_231 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_231, 0, x_225); +lean_ctor_set(x_231, 1, x_5); +return x_231; +} +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; +x_232 = lean_ctor_get(x_5, 0); +x_233 = lean_ctor_get(x_5, 1); +lean_inc(x_233); +lean_inc(x_232); lean_dec(x_5); -lean_inc(x_244); -x_247 = lean_array_uset(x_246, x_7, x_244); -x_248 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_248, 0, x_245); -lean_ctor_set(x_248, 1, x_247); -x_249 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_249, 0, x_244); -lean_ctor_set(x_249, 1, x_248); -return x_249; +x_234 = lean_array_uset(x_232, x_7, x_4); +lean_inc(x_225); +x_235 = lean_array_uset(x_233, x_7, x_225); +x_236 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_236, 0, x_234); +lean_ctor_set(x_236, 1, x_235); +x_237 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_237, 0, x_225); +lean_ctor_set(x_237, 1, x_236); +return x_237; +} } } else { -lean_object* x_250; -lean_dec(x_234); -x_250 = lean_box(0); -x_8 = x_250; -goto block_233; +lean_object* x_238; +x_238 = lean_box(0); +x_8 = x_238; +goto block_214; } } else { -lean_object* x_251; lean_object* x_252; lean_object* x_253; -lean_dec(x_234); +lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_dec(x_4); lean_dec(x_2); -x_251 = lean_ctor_get(x_5, 1); -lean_inc(x_251); -x_252 = lean_array_uget(x_251, x_7); -lean_dec(x_251); -x_253 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_253, 0, x_252); -lean_ctor_set(x_253, 1, x_5); -return x_253; +x_239 = lean_ctor_get(x_5, 1); +lean_inc(x_239); +x_240 = lean_array_uget(x_239, x_7); +lean_dec(x_239); +x_241 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_241, 0, x_240); +lean_ctor_set(x_241, 1, x_5); +return x_241; } -block_233: +block_214: { lean_dec(x_8); switch (lean_obj_tag(x_4)) { @@ -2166,707 +2123,624 @@ 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_15, 0); x_18 = lean_ctor_get(x_15, 1); -x_19 = lean_ctor_get(x_18, 0); -lean_inc(x_19); -lean_inc(x_4); -x_20 = lean_array_uset(x_19, x_7, x_4); -x_21 = !lean_is_exclusive(x_4); +x_19 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_19, 0, x_9); +lean_ctor_set(x_19, 1, x_10); +lean_ctor_set_uint64(x_19, sizeof(void*)*2, x_11); +x_20 = lean_expr_update_app(x_19, x_13, x_17); +x_21 = !lean_is_exclusive(x_18); 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; -x_22 = lean_ctor_get(x_4, 1); -lean_dec(x_22); -x_23 = lean_ctor_get(x_4, 0); -lean_dec(x_23); -x_24 = lean_ctor_get(x_18, 1); -lean_inc(x_24); -lean_dec(x_18); -x_25 = lean_expr_update_app(x_4, x_13, x_17); -lean_inc(x_25); -x_26 = lean_array_uset(x_24, x_7, x_25); -x_27 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_27, 0, x_20); -lean_ctor_set(x_27, 1, x_26); -lean_ctor_set(x_15, 1, x_27); -lean_ctor_set(x_15, 0, x_25); +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_18, 0); +x_23 = lean_ctor_get(x_18, 1); +x_24 = lean_array_uset(x_22, x_7, x_4); +lean_inc(x_20); +x_25 = lean_array_uset(x_23, x_7, x_20); +lean_ctor_set(x_18, 1, x_25); +lean_ctor_set(x_18, 0, x_24); +lean_ctor_set(x_15, 0, x_20); return x_15; } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; -lean_dec(x_4); -x_28 = lean_ctor_get(x_18, 1); -lean_inc(x_28); +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_26 = lean_ctor_get(x_18, 0); +x_27 = lean_ctor_get(x_18, 1); +lean_inc(x_27); +lean_inc(x_26); lean_dec(x_18); -x_29 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_29, 0, x_9); -lean_ctor_set(x_29, 1, x_10); -lean_ctor_set_uint64(x_29, sizeof(void*)*2, x_11); -x_30 = lean_expr_update_app(x_29, x_13, x_17); -lean_inc(x_30); -x_31 = lean_array_uset(x_28, x_7, x_30); -x_32 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_32, 0, x_20); -lean_ctor_set(x_32, 1, x_31); -lean_ctor_set(x_15, 1, x_32); -lean_ctor_set(x_15, 0, x_30); +x_28 = lean_array_uset(x_26, x_7, x_4); +lean_inc(x_20); +x_29 = lean_array_uset(x_27, x_7, x_20); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +lean_ctor_set(x_15, 1, x_30); +lean_ctor_set(x_15, 0, x_20); return x_15; } } 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; 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_15, 0); -x_34 = lean_ctor_get(x_15, 1); -lean_inc(x_34); -lean_inc(x_33); +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_31 = lean_ctor_get(x_15, 0); +x_32 = lean_ctor_get(x_15, 1); +lean_inc(x_32); +lean_inc(x_31); lean_dec(x_15); -x_35 = lean_ctor_get(x_34, 0); +x_33 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_33, 0, x_9); +lean_ctor_set(x_33, 1, x_10); +lean_ctor_set_uint64(x_33, sizeof(void*)*2, x_11); +x_34 = lean_expr_update_app(x_33, x_13, x_31); +x_35 = lean_ctor_get(x_32, 0); lean_inc(x_35); -lean_inc(x_4); -x_36 = lean_array_uset(x_35, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - x_37 = x_4; +x_36 = lean_ctor_get(x_32, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_37 = x_32; } else { - lean_dec_ref(x_4); + lean_dec_ref(x_32); x_37 = lean_box(0); } -x_38 = lean_ctor_get(x_34, 1); -lean_inc(x_38); -lean_dec(x_34); +x_38 = lean_array_uset(x_35, x_7, x_4); +lean_inc(x_34); +x_39 = lean_array_uset(x_36, x_7, x_34); if (lean_is_scalar(x_37)) { - x_39 = lean_alloc_ctor(5, 2, 8); + x_40 = lean_alloc_ctor(0, 2, 0); } else { - x_39 = x_37; + x_40 = x_37; } -lean_ctor_set(x_39, 0, x_9); -lean_ctor_set(x_39, 1, x_10); -lean_ctor_set_uint64(x_39, sizeof(void*)*2, x_11); -x_40 = lean_expr_update_app(x_39, x_13, x_33); -lean_inc(x_40); -x_41 = lean_array_uset(x_38, x_7, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_36); -lean_ctor_set(x_42, 1, x_41); -x_43 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_43, 0, x_40); -lean_ctor_set(x_43, 1, x_42); -return x_43; +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_34); +lean_ctor_set(x_41, 1, x_40); +return x_41; } } case 6: { -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_object* x_50; lean_object* x_51; uint8_t x_52; -x_44 = lean_ctor_get(x_4, 0); +lean_object* x_42; lean_object* x_43; lean_object* x_44; uint64_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_42 = lean_ctor_get(x_4, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_4, 1); +lean_inc(x_43); +x_44 = lean_ctor_get(x_4, 2); lean_inc(x_44); -x_45 = lean_ctor_get(x_4, 1); -lean_inc(x_45); -x_46 = lean_ctor_get(x_4, 2); -lean_inc(x_46); -x_47 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_45); +x_45 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_43); lean_inc(x_2); -x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_45, x_5); -x_49 = lean_ctor_get(x_48, 0); -lean_inc(x_49); -x_50 = lean_ctor_get(x_48, 1); -lean_inc(x_50); -lean_dec(x_48); -lean_inc(x_46); -x_51 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_46, x_50); -x_52 = !lean_is_exclusive(x_51); -if (x_52 == 0) +x_46 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_43, x_5); +x_47 = lean_ctor_get(x_46, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_46, 1); +lean_inc(x_48); +lean_dec(x_46); +lean_inc(x_44); +x_49 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_44, x_48); +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; -x_53 = lean_ctor_get(x_51, 0); -x_54 = lean_ctor_get(x_51, 1); -x_55 = lean_ctor_get(x_54, 0); +lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; uint8_t x_56; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +x_53 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_53, 0, x_42); +lean_ctor_set(x_53, 1, x_43); +lean_ctor_set(x_53, 2, x_44); +lean_ctor_set_uint64(x_53, sizeof(void*)*3, x_45); +x_54 = (uint8_t)((x_45 << 24) >> 61); +x_55 = lean_expr_update_lambda(x_53, x_54, x_47, x_51); +x_56 = !lean_is_exclusive(x_52); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_57 = lean_ctor_get(x_52, 0); +x_58 = lean_ctor_get(x_52, 1); +x_59 = lean_array_uset(x_57, x_7, x_4); lean_inc(x_55); -lean_inc(x_4); -x_56 = lean_array_uset(x_55, x_7, x_4); -x_57 = !lean_is_exclusive(x_4); -if (x_57 == 0) +x_60 = lean_array_uset(x_58, x_7, x_55); +lean_ctor_set(x_52, 1, x_60); +lean_ctor_set(x_52, 0, x_59); +lean_ctor_set(x_49, 0, x_55); +return x_49; +} +else { -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_58 = lean_ctor_get(x_4, 2); -lean_dec(x_58); -x_59 = lean_ctor_get(x_4, 1); -lean_dec(x_59); -x_60 = lean_ctor_get(x_4, 0); -lean_dec(x_60); -x_61 = lean_ctor_get(x_54, 1); +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_52, 0); +x_62 = lean_ctor_get(x_52, 1); +lean_inc(x_62); lean_inc(x_61); -lean_dec(x_54); -x_62 = (uint8_t)((x_47 << 24) >> 61); -x_63 = lean_expr_update_lambda(x_4, x_62, x_49, x_53); -lean_inc(x_63); -x_64 = lean_array_uset(x_61, x_7, x_63); +lean_dec(x_52); +x_63 = lean_array_uset(x_61, x_7, x_4); +lean_inc(x_55); +x_64 = lean_array_uset(x_62, x_7, x_55); x_65 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_65, 0, x_56); +lean_ctor_set(x_65, 0, x_63); lean_ctor_set(x_65, 1, x_64); -lean_ctor_set(x_51, 1, x_65); -lean_ctor_set(x_51, 0, x_63); -return x_51; +lean_ctor_set(x_49, 1, x_65); +lean_ctor_set(x_49, 0, x_55); +return x_49; +} } else { -lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; -lean_dec(x_4); -x_66 = lean_ctor_get(x_54, 1); +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; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_66 = lean_ctor_get(x_49, 0); +x_67 = lean_ctor_get(x_49, 1); +lean_inc(x_67); lean_inc(x_66); -lean_dec(x_54); -x_67 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_67, 0, x_44); -lean_ctor_set(x_67, 1, x_45); -lean_ctor_set(x_67, 2, x_46); -lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_47); -x_68 = (uint8_t)((x_47 << 24) >> 61); -x_69 = lean_expr_update_lambda(x_67, x_68, x_49, x_53); -lean_inc(x_69); -x_70 = lean_array_uset(x_66, x_7, x_69); -x_71 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_71, 0, x_56); -lean_ctor_set(x_71, 1, x_70); -lean_ctor_set(x_51, 1, x_71); -lean_ctor_set(x_51, 0, x_69); -return x_51; -} -} -else -{ -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_72 = lean_ctor_get(x_51, 0); -x_73 = lean_ctor_get(x_51, 1); -lean_inc(x_73); +lean_dec(x_49); +x_68 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_68, 0, x_42); +lean_ctor_set(x_68, 1, x_43); +lean_ctor_set(x_68, 2, x_44); +lean_ctor_set_uint64(x_68, sizeof(void*)*3, x_45); +x_69 = (uint8_t)((x_45 << 24) >> 61); +x_70 = lean_expr_update_lambda(x_68, x_69, x_47, x_66); +x_71 = lean_ctor_get(x_67, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_67, 1); lean_inc(x_72); -lean_dec(x_51); -x_74 = lean_ctor_get(x_73, 0); -lean_inc(x_74); -lean_inc(x_4); -x_75 = lean_array_uset(x_74, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_76 = x_4; +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_73 = x_67; } else { - lean_dec_ref(x_4); - x_76 = lean_box(0); + lean_dec_ref(x_67); + x_73 = lean_box(0); } -x_77 = lean_ctor_get(x_73, 1); -lean_inc(x_77); -lean_dec(x_73); -if (lean_is_scalar(x_76)) { - x_78 = lean_alloc_ctor(6, 3, 8); +x_74 = lean_array_uset(x_71, x_7, x_4); +lean_inc(x_70); +x_75 = lean_array_uset(x_72, x_7, x_70); +if (lean_is_scalar(x_73)) { + x_76 = lean_alloc_ctor(0, 2, 0); } else { - x_78 = x_76; + x_76 = x_73; } -lean_ctor_set(x_78, 0, x_44); -lean_ctor_set(x_78, 1, x_45); -lean_ctor_set(x_78, 2, x_46); -lean_ctor_set_uint64(x_78, sizeof(void*)*3, x_47); -x_79 = (uint8_t)((x_47 << 24) >> 61); -x_80 = lean_expr_update_lambda(x_78, x_79, x_49, x_72); -lean_inc(x_80); -x_81 = lean_array_uset(x_77, x_7, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_75); -lean_ctor_set(x_82, 1, x_81); -x_83 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_83, 0, x_80); -lean_ctor_set(x_83, 1, x_82); -return x_83; +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_70); +lean_ctor_set(x_77, 1, x_76); +return x_77; } } case 7: { -lean_object* x_84; lean_object* x_85; lean_object* x_86; uint64_t x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; uint8_t x_92; -x_84 = lean_ctor_get(x_4, 0); -lean_inc(x_84); -x_85 = lean_ctor_get(x_4, 1); -lean_inc(x_85); -x_86 = lean_ctor_get(x_4, 2); -lean_inc(x_86); -x_87 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_85); +lean_object* x_78; lean_object* x_79; lean_object* x_80; uint64_t x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; +x_78 = lean_ctor_get(x_4, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_4, 1); +lean_inc(x_79); +x_80 = lean_ctor_get(x_4, 2); +lean_inc(x_80); +x_81 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_79); lean_inc(x_2); -x_88 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_85, x_5); -x_89 = lean_ctor_get(x_88, 0); -lean_inc(x_89); -x_90 = lean_ctor_get(x_88, 1); -lean_inc(x_90); -lean_dec(x_88); -lean_inc(x_86); -x_91 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_86, x_90); -x_92 = !lean_is_exclusive(x_91); +x_82 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_79, x_5); +x_83 = lean_ctor_get(x_82, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_82, 1); +lean_inc(x_84); +lean_dec(x_82); +lean_inc(x_80); +x_85 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_80, x_84); +x_86 = !lean_is_exclusive(x_85); +if (x_86 == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; uint8_t x_92; +x_87 = lean_ctor_get(x_85, 0); +x_88 = lean_ctor_get(x_85, 1); +x_89 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_89, 0, x_78); +lean_ctor_set(x_89, 1, x_79); +lean_ctor_set(x_89, 2, x_80); +lean_ctor_set_uint64(x_89, sizeof(void*)*3, x_81); +x_90 = (uint8_t)((x_81 << 24) >> 61); +x_91 = lean_expr_update_forall(x_89, x_90, x_83, x_87); +x_92 = !lean_is_exclusive(x_88); if (x_92 == 0) { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; uint8_t x_97; -x_93 = lean_ctor_get(x_91, 0); -x_94 = lean_ctor_get(x_91, 1); -x_95 = lean_ctor_get(x_94, 0); -lean_inc(x_95); -lean_inc(x_4); -x_96 = lean_array_uset(x_95, x_7, x_4); -x_97 = !lean_is_exclusive(x_4); -if (x_97 == 0) +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_93 = lean_ctor_get(x_88, 0); +x_94 = lean_ctor_get(x_88, 1); +x_95 = lean_array_uset(x_93, x_7, x_4); +lean_inc(x_91); +x_96 = lean_array_uset(x_94, x_7, x_91); +lean_ctor_set(x_88, 1, x_96); +lean_ctor_set(x_88, 0, x_95); +lean_ctor_set(x_85, 0, x_91); +return x_85; +} +else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; -x_98 = lean_ctor_get(x_4, 2); -lean_dec(x_98); -x_99 = lean_ctor_get(x_4, 1); -lean_dec(x_99); -x_100 = lean_ctor_get(x_4, 0); -lean_dec(x_100); -x_101 = lean_ctor_get(x_94, 1); -lean_inc(x_101); -lean_dec(x_94); -x_102 = (uint8_t)((x_87 << 24) >> 61); -x_103 = lean_expr_update_forall(x_4, x_102, x_89, x_93); +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_88, 0); +x_98 = lean_ctor_get(x_88, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_88); +x_99 = lean_array_uset(x_97, x_7, x_4); +lean_inc(x_91); +x_100 = lean_array_uset(x_98, x_7, x_91); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_85, 1, x_101); +lean_ctor_set(x_85, 0, x_91); +return x_85; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t 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; +x_102 = lean_ctor_get(x_85, 0); +x_103 = lean_ctor_get(x_85, 1); lean_inc(x_103); -x_104 = lean_array_uset(x_101, x_7, x_103); -x_105 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_105, 0, x_96); -lean_ctor_set(x_105, 1, x_104); -lean_ctor_set(x_91, 1, x_105); -lean_ctor_set(x_91, 0, x_103); -return x_91; +lean_inc(x_102); +lean_dec(x_85); +x_104 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_104, 0, x_78); +lean_ctor_set(x_104, 1, x_79); +lean_ctor_set(x_104, 2, x_80); +lean_ctor_set_uint64(x_104, sizeof(void*)*3, x_81); +x_105 = (uint8_t)((x_81 << 24) >> 61); +x_106 = lean_expr_update_forall(x_104, x_105, x_83, x_102); +x_107 = lean_ctor_get(x_103, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_103, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); + x_109 = x_103; +} else { + lean_dec_ref(x_103); + x_109 = lean_box(0); } -else -{ -lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; -lean_dec(x_4); -x_106 = lean_ctor_get(x_94, 1); +x_110 = lean_array_uset(x_107, x_7, x_4); lean_inc(x_106); -lean_dec(x_94); -x_107 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_107, 0, x_84); -lean_ctor_set(x_107, 1, x_85); -lean_ctor_set(x_107, 2, x_86); -lean_ctor_set_uint64(x_107, sizeof(void*)*3, x_87); -x_108 = (uint8_t)((x_87 << 24) >> 61); -x_109 = lean_expr_update_forall(x_107, x_108, x_89, x_93); -lean_inc(x_109); -x_110 = lean_array_uset(x_106, x_7, x_109); -x_111 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_111, 0, x_96); -lean_ctor_set(x_111, 1, x_110); -lean_ctor_set(x_91, 1, x_111); -lean_ctor_set(x_91, 0, x_109); -return x_91; -} -} -else -{ -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; lean_object* x_121; lean_object* x_122; lean_object* x_123; -x_112 = lean_ctor_get(x_91, 0); -x_113 = lean_ctor_get(x_91, 1); -lean_inc(x_113); -lean_inc(x_112); -lean_dec(x_91); -x_114 = lean_ctor_get(x_113, 0); -lean_inc(x_114); -lean_inc(x_4); -x_115 = lean_array_uset(x_114, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_116 = x_4; +x_111 = lean_array_uset(x_108, x_7, x_106); +if (lean_is_scalar(x_109)) { + x_112 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_4); - x_116 = lean_box(0); + x_112 = x_109; } -x_117 = lean_ctor_get(x_113, 1); -lean_inc(x_117); -lean_dec(x_113); -if (lean_is_scalar(x_116)) { - x_118 = lean_alloc_ctor(7, 3, 8); -} else { - x_118 = x_116; -} -lean_ctor_set(x_118, 0, x_84); -lean_ctor_set(x_118, 1, x_85); -lean_ctor_set(x_118, 2, x_86); -lean_ctor_set_uint64(x_118, sizeof(void*)*3, x_87); -x_119 = (uint8_t)((x_87 << 24) >> 61); -x_120 = lean_expr_update_forall(x_118, x_119, x_89, x_112); -lean_inc(x_120); -x_121 = lean_array_uset(x_117, x_7, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_115); -lean_ctor_set(x_122, 1, x_121); -x_123 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_123, 0, x_120); -lean_ctor_set(x_123, 1, x_122); -return x_123; +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_106); +lean_ctor_set(x_113, 1, x_112); +return x_113; } } case 8: { -lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint64_t 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; uint8_t x_136; -x_124 = lean_ctor_get(x_4, 0); +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint64_t 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; +x_114 = lean_ctor_get(x_4, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_4, 1); +lean_inc(x_115); +x_116 = lean_ctor_get(x_4, 2); +lean_inc(x_116); +x_117 = lean_ctor_get(x_4, 3); +lean_inc(x_117); +x_118 = lean_ctor_get_uint64(x_4, sizeof(void*)*4); +lean_inc(x_115); +lean_inc(x_2); +x_119 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_115, x_5); +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +lean_inc(x_116); +lean_inc(x_2); +x_122 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_116, x_121); +x_123 = lean_ctor_get(x_122, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_122, 1); lean_inc(x_124); -x_125 = lean_ctor_get(x_4, 1); -lean_inc(x_125); -x_126 = lean_ctor_get(x_4, 2); -lean_inc(x_126); -x_127 = lean_ctor_get(x_4, 3); -lean_inc(x_127); -x_128 = lean_ctor_get_uint64(x_4, sizeof(void*)*4); -lean_inc(x_125); -lean_inc(x_2); -x_129 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_125, x_5); -x_130 = lean_ctor_get(x_129, 0); +lean_dec(x_122); +lean_inc(x_117); +x_125 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_117, x_124); +x_126 = !lean_is_exclusive(x_125); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; +x_127 = lean_ctor_get(x_125, 0); +x_128 = lean_ctor_get(x_125, 1); +x_129 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_129, 0, x_114); +lean_ctor_set(x_129, 1, x_115); +lean_ctor_set(x_129, 2, x_116); +lean_ctor_set(x_129, 3, x_117); +lean_ctor_set_uint64(x_129, sizeof(void*)*4, x_118); +x_130 = lean_expr_update_let(x_129, x_120, x_123, x_127); +x_131 = !lean_is_exclusive(x_128); +if (x_131 == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_132 = lean_ctor_get(x_128, 0); +x_133 = lean_ctor_get(x_128, 1); +x_134 = lean_array_uset(x_132, x_7, x_4); lean_inc(x_130); -x_131 = lean_ctor_get(x_129, 1); -lean_inc(x_131); -lean_dec(x_129); -lean_inc(x_126); -lean_inc(x_2); -x_132 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_126, x_131); -x_133 = lean_ctor_get(x_132, 0); -lean_inc(x_133); -x_134 = lean_ctor_get(x_132, 1); -lean_inc(x_134); -lean_dec(x_132); -lean_inc(x_127); -x_135 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_127, x_134); -x_136 = !lean_is_exclusive(x_135); -if (x_136 == 0) +x_135 = lean_array_uset(x_133, x_7, x_130); +lean_ctor_set(x_128, 1, x_135); +lean_ctor_set(x_128, 0, x_134); +lean_ctor_set(x_125, 0, x_130); +return x_125; +} +else { -lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; uint8_t x_141; -x_137 = lean_ctor_get(x_135, 0); -x_138 = lean_ctor_get(x_135, 1); -x_139 = lean_ctor_get(x_138, 0); -lean_inc(x_139); -lean_inc(x_4); -x_140 = lean_array_uset(x_139, x_7, x_4); -x_141 = !lean_is_exclusive(x_4); -if (x_141 == 0) +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_128, 0); +x_137 = lean_ctor_get(x_128, 1); +lean_inc(x_137); +lean_inc(x_136); +lean_dec(x_128); +x_138 = lean_array_uset(x_136, x_7, x_4); +lean_inc(x_130); +x_139 = lean_array_uset(x_137, x_7, x_130); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_138); +lean_ctor_set(x_140, 1, x_139); +lean_ctor_set(x_125, 1, x_140); +lean_ctor_set(x_125, 0, x_130); +return x_125; +} +} +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; -x_142 = lean_ctor_get(x_4, 3); -lean_dec(x_142); -x_143 = lean_ctor_get(x_4, 2); -lean_dec(x_143); -x_144 = lean_ctor_get(x_4, 1); -lean_dec(x_144); -x_145 = lean_ctor_get(x_4, 0); -lean_dec(x_145); -x_146 = lean_ctor_get(x_138, 1); +lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_141 = lean_ctor_get(x_125, 0); +x_142 = lean_ctor_get(x_125, 1); +lean_inc(x_142); +lean_inc(x_141); +lean_dec(x_125); +x_143 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_143, 0, x_114); +lean_ctor_set(x_143, 1, x_115); +lean_ctor_set(x_143, 2, x_116); +lean_ctor_set(x_143, 3, x_117); +lean_ctor_set_uint64(x_143, sizeof(void*)*4, x_118); +x_144 = lean_expr_update_let(x_143, x_120, x_123, x_141); +x_145 = lean_ctor_get(x_142, 0); +lean_inc(x_145); +x_146 = lean_ctor_get(x_142, 1); lean_inc(x_146); -lean_dec(x_138); -x_147 = lean_expr_update_let(x_4, x_130, x_133, x_137); -lean_inc(x_147); -x_148 = lean_array_uset(x_146, x_7, x_147); -x_149 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_149, 0, x_140); -lean_ctor_set(x_149, 1, x_148); -lean_ctor_set(x_135, 1, x_149); -lean_ctor_set(x_135, 0, x_147); -return x_135; -} -else -{ -lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; -lean_dec(x_4); -x_150 = lean_ctor_get(x_138, 1); -lean_inc(x_150); -lean_dec(x_138); -x_151 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_151, 0, x_124); -lean_ctor_set(x_151, 1, x_125); -lean_ctor_set(x_151, 2, x_126); -lean_ctor_set(x_151, 3, x_127); -lean_ctor_set_uint64(x_151, sizeof(void*)*4, x_128); -x_152 = lean_expr_update_let(x_151, x_130, x_133, x_137); -lean_inc(x_152); -x_153 = lean_array_uset(x_150, x_7, x_152); -x_154 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_154, 0, x_140); -lean_ctor_set(x_154, 1, x_153); -lean_ctor_set(x_135, 1, x_154); -lean_ctor_set(x_135, 0, x_152); -return x_135; -} -} -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; lean_object* x_164; lean_object* x_165; -x_155 = lean_ctor_get(x_135, 0); -x_156 = lean_ctor_get(x_135, 1); -lean_inc(x_156); -lean_inc(x_155); -lean_dec(x_135); -x_157 = lean_ctor_get(x_156, 0); -lean_inc(x_157); -lean_inc(x_4); -x_158 = lean_array_uset(x_157, x_7, x_4); -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_159 = x_4; +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_4); - x_159 = lean_box(0); + lean_dec_ref(x_142); + x_147 = lean_box(0); } -x_160 = lean_ctor_get(x_156, 1); -lean_inc(x_160); -lean_dec(x_156); -if (lean_is_scalar(x_159)) { - x_161 = lean_alloc_ctor(8, 4, 8); +x_148 = lean_array_uset(x_145, x_7, x_4); +lean_inc(x_144); +x_149 = lean_array_uset(x_146, x_7, x_144); +if (lean_is_scalar(x_147)) { + x_150 = lean_alloc_ctor(0, 2, 0); } else { - x_161 = x_159; + x_150 = x_147; } -lean_ctor_set(x_161, 0, x_124); -lean_ctor_set(x_161, 1, x_125); -lean_ctor_set(x_161, 2, x_126); -lean_ctor_set(x_161, 3, x_127); -lean_ctor_set_uint64(x_161, sizeof(void*)*4, x_128); -x_162 = lean_expr_update_let(x_161, x_130, x_133, x_155); -lean_inc(x_162); -x_163 = lean_array_uset(x_160, x_7, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_158); -lean_ctor_set(x_164, 1, x_163); -x_165 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_165, 0, x_162); -lean_ctor_set(x_165, 1, x_164); -return x_165; +lean_ctor_set(x_150, 0, x_148); +lean_ctor_set(x_150, 1, x_149); +x_151 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_151, 0, x_144); +lean_ctor_set(x_151, 1, x_150); +return x_151; } } case 10: { -lean_object* x_166; lean_object* x_167; uint64_t x_168; lean_object* x_169; uint8_t x_170; -x_166 = lean_ctor_get(x_4, 0); +lean_object* x_152; lean_object* x_153; uint64_t x_154; lean_object* x_155; uint8_t x_156; +x_152 = lean_ctor_get(x_4, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_4, 1); +lean_inc(x_153); +x_154 = lean_ctor_get_uint64(x_4, sizeof(void*)*2); +lean_inc(x_153); +x_155 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_153, x_5); +x_156 = !lean_is_exclusive(x_155); +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_155, 0); +x_158 = lean_ctor_get(x_155, 1); +x_159 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_159, 0, x_152); +lean_ctor_set(x_159, 1, x_153); +lean_ctor_set_uint64(x_159, sizeof(void*)*2, x_154); +x_160 = lean_expr_update_mdata(x_159, x_157); +x_161 = !lean_is_exclusive(x_158); +if (x_161 == 0) +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_162 = lean_ctor_get(x_158, 0); +x_163 = lean_ctor_get(x_158, 1); +x_164 = lean_array_uset(x_162, x_7, x_4); +lean_inc(x_160); +x_165 = lean_array_uset(x_163, x_7, x_160); +lean_ctor_set(x_158, 1, x_165); +lean_ctor_set(x_158, 0, x_164); +lean_ctor_set(x_155, 0, x_160); +return x_155; +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_166 = lean_ctor_get(x_158, 0); +x_167 = lean_ctor_get(x_158, 1); +lean_inc(x_167); lean_inc(x_166); -x_167 = lean_ctor_get(x_4, 1); -lean_inc(x_167); -x_168 = lean_ctor_get_uint64(x_4, sizeof(void*)*2); -lean_inc(x_167); -x_169 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_167, x_5); -x_170 = !lean_is_exclusive(x_169); -if (x_170 == 0) +lean_dec(x_158); +x_168 = lean_array_uset(x_166, x_7, x_4); +lean_inc(x_160); +x_169 = lean_array_uset(x_167, x_7, x_160); +x_170 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_170, 0, x_168); +lean_ctor_set(x_170, 1, x_169); +lean_ctor_set(x_155, 1, x_170); +lean_ctor_set(x_155, 0, x_160); +return x_155; +} +} +else { -lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; -x_171 = lean_ctor_get(x_169, 0); -x_172 = lean_ctor_get(x_169, 1); -x_173 = lean_ctor_get(x_172, 0); -lean_inc(x_173); -lean_inc(x_4); -x_174 = lean_array_uset(x_173, x_7, x_4); -x_175 = !lean_is_exclusive(x_4); -if (x_175 == 0) -{ -lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; -x_176 = lean_ctor_get(x_4, 1); -lean_dec(x_176); -x_177 = lean_ctor_get(x_4, 0); -lean_dec(x_177); -x_178 = lean_ctor_get(x_172, 1); -lean_inc(x_178); -lean_dec(x_172); -x_179 = lean_expr_update_mdata(x_4, x_171); -lean_inc(x_179); -x_180 = lean_array_uset(x_178, x_7, x_179); +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_171 = lean_ctor_get(x_155, 0); +x_172 = lean_ctor_get(x_155, 1); +lean_inc(x_172); +lean_inc(x_171); +lean_dec(x_155); +x_173 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_173, 0, x_152); +lean_ctor_set(x_173, 1, x_153); +lean_ctor_set_uint64(x_173, sizeof(void*)*2, x_154); +x_174 = lean_expr_update_mdata(x_173, x_171); +x_175 = lean_ctor_get(x_172, 0); +lean_inc(x_175); +x_176 = lean_ctor_get(x_172, 1); +lean_inc(x_176); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_177 = x_172; +} else { + lean_dec_ref(x_172); + x_177 = lean_box(0); +} +x_178 = lean_array_uset(x_175, x_7, x_4); +lean_inc(x_174); +x_179 = lean_array_uset(x_176, x_7, x_174); +if (lean_is_scalar(x_177)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_177; +} +lean_ctor_set(x_180, 0, x_178); +lean_ctor_set(x_180, 1, x_179); x_181 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_181, 0, x_174); lean_ctor_set(x_181, 1, x_180); -lean_ctor_set(x_169, 1, x_181); -lean_ctor_set(x_169, 0, x_179); -return x_169; -} -else -{ -lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; -lean_dec(x_4); -x_182 = lean_ctor_get(x_172, 1); -lean_inc(x_182); -lean_dec(x_172); -x_183 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_183, 0, x_166); -lean_ctor_set(x_183, 1, x_167); -lean_ctor_set_uint64(x_183, sizeof(void*)*2, x_168); -x_184 = lean_expr_update_mdata(x_183, x_171); -lean_inc(x_184); -x_185 = lean_array_uset(x_182, x_7, x_184); -x_186 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_186, 0, x_174); -lean_ctor_set(x_186, 1, x_185); -lean_ctor_set(x_169, 1, x_186); -lean_ctor_set(x_169, 0, x_184); -return x_169; -} -} -else -{ -lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; -x_187 = lean_ctor_get(x_169, 0); -x_188 = lean_ctor_get(x_169, 1); -lean_inc(x_188); -lean_inc(x_187); -lean_dec(x_169); -x_189 = lean_ctor_get(x_188, 0); -lean_inc(x_189); -lean_inc(x_4); -x_190 = lean_array_uset(x_189, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - x_191 = x_4; -} else { - lean_dec_ref(x_4); - x_191 = lean_box(0); -} -x_192 = lean_ctor_get(x_188, 1); -lean_inc(x_192); -lean_dec(x_188); -if (lean_is_scalar(x_191)) { - x_193 = lean_alloc_ctor(10, 2, 8); -} else { - x_193 = x_191; -} -lean_ctor_set(x_193, 0, x_166); -lean_ctor_set(x_193, 1, x_167); -lean_ctor_set_uint64(x_193, sizeof(void*)*2, x_168); -x_194 = lean_expr_update_mdata(x_193, x_187); -lean_inc(x_194); -x_195 = lean_array_uset(x_192, x_7, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_190); -lean_ctor_set(x_196, 1, x_195); -x_197 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_197, 0, x_194); -lean_ctor_set(x_197, 1, x_196); -return x_197; +return x_181; } } case 11: { -lean_object* x_198; lean_object* x_199; lean_object* x_200; uint64_t x_201; lean_object* x_202; uint8_t x_203; -x_198 = lean_ctor_get(x_4, 0); +lean_object* x_182; lean_object* x_183; lean_object* x_184; uint64_t x_185; lean_object* x_186; uint8_t x_187; +x_182 = lean_ctor_get(x_4, 0); +lean_inc(x_182); +x_183 = lean_ctor_get(x_4, 1); +lean_inc(x_183); +x_184 = lean_ctor_get(x_4, 2); +lean_inc(x_184); +x_185 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_184); +x_186 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_184, x_5); +x_187 = !lean_is_exclusive(x_186); +if (x_187 == 0) +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; uint8_t x_192; +x_188 = lean_ctor_get(x_186, 0); +x_189 = lean_ctor_get(x_186, 1); +x_190 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_190, 0, x_182); +lean_ctor_set(x_190, 1, x_183); +lean_ctor_set(x_190, 2, x_184); +lean_ctor_set_uint64(x_190, sizeof(void*)*3, x_185); +x_191 = lean_expr_update_proj(x_190, x_188); +x_192 = !lean_is_exclusive(x_189); +if (x_192 == 0) +{ +lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; +x_193 = lean_ctor_get(x_189, 0); +x_194 = lean_ctor_get(x_189, 1); +x_195 = lean_array_uset(x_193, x_7, x_4); +lean_inc(x_191); +x_196 = lean_array_uset(x_194, x_7, x_191); +lean_ctor_set(x_189, 1, x_196); +lean_ctor_set(x_189, 0, x_195); +lean_ctor_set(x_186, 0, x_191); +return x_186; +} +else +{ +lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; +x_197 = lean_ctor_get(x_189, 0); +x_198 = lean_ctor_get(x_189, 1); lean_inc(x_198); -x_199 = lean_ctor_get(x_4, 1); -lean_inc(x_199); -x_200 = lean_ctor_get(x_4, 2); -lean_inc(x_200); -x_201 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_200); -x_202 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__2(x_1, x_2, x_3, x_200, x_5); -x_203 = !lean_is_exclusive(x_202); -if (x_203 == 0) +lean_inc(x_197); +lean_dec(x_189); +x_199 = lean_array_uset(x_197, x_7, x_4); +lean_inc(x_191); +x_200 = lean_array_uset(x_198, x_7, x_191); +x_201 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_201, 0, x_199); +lean_ctor_set(x_201, 1, x_200); +lean_ctor_set(x_186, 1, x_201); +lean_ctor_set(x_186, 0, x_191); +return x_186; +} +} +else { -lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; uint8_t x_208; -x_204 = lean_ctor_get(x_202, 0); -x_205 = lean_ctor_get(x_202, 1); -x_206 = lean_ctor_get(x_205, 0); +lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; +x_202 = lean_ctor_get(x_186, 0); +x_203 = lean_ctor_get(x_186, 1); +lean_inc(x_203); +lean_inc(x_202); +lean_dec(x_186); +x_204 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_204, 0, x_182); +lean_ctor_set(x_204, 1, x_183); +lean_ctor_set(x_204, 2, x_184); +lean_ctor_set_uint64(x_204, sizeof(void*)*3, x_185); +x_205 = lean_expr_update_proj(x_204, x_202); +x_206 = lean_ctor_get(x_203, 0); lean_inc(x_206); -lean_inc(x_4); -x_207 = lean_array_uset(x_206, x_7, x_4); -x_208 = !lean_is_exclusive(x_4); -if (x_208 == 0) -{ -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; -x_209 = lean_ctor_get(x_4, 2); -lean_dec(x_209); -x_210 = lean_ctor_get(x_4, 1); -lean_dec(x_210); -x_211 = lean_ctor_get(x_4, 0); -lean_dec(x_211); -x_212 = lean_ctor_get(x_205, 1); -lean_inc(x_212); -lean_dec(x_205); -x_213 = lean_expr_update_proj(x_4, x_204); -lean_inc(x_213); -x_214 = lean_array_uset(x_212, x_7, x_213); -x_215 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_215, 0, x_207); -lean_ctor_set(x_215, 1, x_214); -lean_ctor_set(x_202, 1, x_215); -lean_ctor_set(x_202, 0, x_213); -return x_202; -} -else -{ -lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; -lean_dec(x_4); -x_216 = lean_ctor_get(x_205, 1); -lean_inc(x_216); -lean_dec(x_205); -x_217 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_217, 0, x_198); -lean_ctor_set(x_217, 1, x_199); -lean_ctor_set(x_217, 2, x_200); -lean_ctor_set_uint64(x_217, sizeof(void*)*3, x_201); -x_218 = lean_expr_update_proj(x_217, x_204); -lean_inc(x_218); -x_219 = lean_array_uset(x_216, x_7, x_218); -x_220 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_220, 0, x_207); -lean_ctor_set(x_220, 1, x_219); -lean_ctor_set(x_202, 1, x_220); -lean_ctor_set(x_202, 0, x_218); -return x_202; -} -} -else -{ -lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; -x_221 = lean_ctor_get(x_202, 0); -x_222 = lean_ctor_get(x_202, 1); -lean_inc(x_222); -lean_inc(x_221); -lean_dec(x_202); -x_223 = lean_ctor_get(x_222, 0); -lean_inc(x_223); -lean_inc(x_4); -x_224 = lean_array_uset(x_223, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_225 = x_4; +x_207 = lean_ctor_get(x_203, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_203)) { + lean_ctor_release(x_203, 0); + lean_ctor_release(x_203, 1); + x_208 = x_203; } else { - lean_dec_ref(x_4); - x_225 = lean_box(0); + lean_dec_ref(x_203); + x_208 = lean_box(0); } -x_226 = lean_ctor_get(x_222, 1); -lean_inc(x_226); -lean_dec(x_222); -if (lean_is_scalar(x_225)) { - x_227 = lean_alloc_ctor(11, 3, 8); +x_209 = lean_array_uset(x_206, x_7, x_4); +lean_inc(x_205); +x_210 = lean_array_uset(x_207, x_7, x_205); +if (lean_is_scalar(x_208)) { + x_211 = lean_alloc_ctor(0, 2, 0); } else { - x_227 = x_225; + x_211 = x_208; } -lean_ctor_set(x_227, 0, x_198); -lean_ctor_set(x_227, 1, x_199); -lean_ctor_set(x_227, 2, x_200); -lean_ctor_set_uint64(x_227, sizeof(void*)*3, x_201); -x_228 = lean_expr_update_proj(x_227, x_221); -lean_inc(x_228); -x_229 = lean_array_uset(x_226, x_7, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_224); -lean_ctor_set(x_230, 1, x_229); -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_228); -lean_ctor_set(x_231, 1, x_230); -return x_231; +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_205); +lean_ctor_set(x_212, 1, x_211); +return x_212; } } default: { -lean_object* x_232; +lean_object* x_213; lean_dec(x_2); -x_232 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_232, 0, x_4); -lean_ctor_set(x_232, 1, x_5); -return x_232; +x_213 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_213, 0, x_4); +lean_ctor_set(x_213, 1, x_5); +return x_213; } } } @@ -5192,84 +5066,104 @@ return x_11; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(lean_object* x_1, lean_object* x_2, size_t x_3, lean_object* x_4, lean_object* x_5) { _start: { -size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_234; lean_object* x_235; size_t x_236; uint8_t x_237; +size_t x_6; size_t x_7; lean_object* x_8; lean_object* x_215; lean_object* x_216; size_t x_217; uint8_t x_218; x_6 = lean_ptr_addr(x_4); x_7 = x_3 == 0 ? x_6 : x_6 % x_3; -x_234 = lean_ctor_get(x_5, 0); -lean_inc(x_234); -x_235 = lean_array_uget(x_234, x_7); -x_236 = lean_ptr_addr(x_235); -lean_dec(x_235); -x_237 = x_236 == x_6; -if (x_237 == 0) +x_215 = lean_ctor_get(x_5, 0); +lean_inc(x_215); +x_216 = lean_array_uget(x_215, x_7); +lean_dec(x_215); +x_217 = lean_ptr_addr(x_216); +lean_dec(x_216); +x_218 = x_217 == x_6; +if (x_218 == 0) { if (lean_obj_tag(x_4) == 4) { -lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; uint8_t x_242; -x_238 = lean_ctor_get(x_4, 0); -lean_inc(x_238); -x_239 = lean_ctor_get(x_4, 1); -lean_inc(x_239); -lean_inc(x_238); -x_240 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1___lambda__1___boxed), 2, 1); -lean_closure_set(x_240, 0, x_238); -x_241 = lean_unsigned_to_nat(0u); -x_242 = l_Array_anyMUnsafe___at_Array_any___spec__1___rarg(x_240, x_1, x_241, x_2); -if (x_242 == 0) +lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; uint8_t x_223; +x_219 = lean_ctor_get(x_4, 0); +lean_inc(x_219); +x_220 = lean_ctor_get(x_4, 1); +lean_inc(x_220); +lean_inc(x_219); +x_221 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_fixLevelParams___spec__1___lambda__1___boxed), 2, 1); +lean_closure_set(x_221, 0, x_219); +x_222 = lean_unsigned_to_nat(0u); +x_223 = l_Array_anyMUnsafe___at_Array_any___spec__1___rarg(x_221, x_1, x_222, x_2); +if (x_223 == 0) { -lean_object* x_243; -lean_dec(x_239); -lean_dec(x_238); -lean_dec(x_234); -x_243 = lean_box(0); -x_8 = x_243; -goto block_233; +lean_object* x_224; +lean_dec(x_220); +lean_dec(x_219); +x_224 = lean_box(0); +x_8 = x_224; +goto block_214; } else { -lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; -x_244 = l_Lean_Compiler_mkUnsafeRecName___closed__1; -x_245 = lean_name_mk_string(x_238, x_244); -x_246 = l_Lean_mkConst(x_245, x_239); -x_247 = lean_array_uset(x_234, x_7, x_4); -x_248 = lean_ctor_get(x_5, 1); -lean_inc(x_248); +lean_object* x_225; lean_object* x_226; lean_object* x_227; uint8_t x_228; +x_225 = l_Lean_Compiler_mkUnsafeRecName___closed__1; +x_226 = lean_name_mk_string(x_219, x_225); +x_227 = l_Lean_mkConst(x_226, x_220); +x_228 = !lean_is_exclusive(x_5); +if (x_228 == 0) +{ +lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; +x_229 = lean_ctor_get(x_5, 0); +x_230 = lean_ctor_get(x_5, 1); +x_231 = lean_array_uset(x_229, x_7, x_4); +lean_inc(x_227); +x_232 = lean_array_uset(x_230, x_7, x_227); +lean_ctor_set(x_5, 1, x_232); +lean_ctor_set(x_5, 0, x_231); +x_233 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_233, 0, x_227); +lean_ctor_set(x_233, 1, x_5); +return x_233; +} +else +{ +lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; +x_234 = lean_ctor_get(x_5, 0); +x_235 = lean_ctor_get(x_5, 1); +lean_inc(x_235); +lean_inc(x_234); lean_dec(x_5); -lean_inc(x_246); -x_249 = lean_array_uset(x_248, x_7, x_246); -x_250 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_250, 0, x_247); -lean_ctor_set(x_250, 1, x_249); -x_251 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_251, 0, x_246); -lean_ctor_set(x_251, 1, x_250); -return x_251; +x_236 = lean_array_uset(x_234, x_7, x_4); +lean_inc(x_227); +x_237 = lean_array_uset(x_235, x_7, x_227); +x_238 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_238, 0, x_236); +lean_ctor_set(x_238, 1, x_237); +x_239 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_239, 0, x_227); +lean_ctor_set(x_239, 1, x_238); +return x_239; +} } } else { -lean_object* x_252; -lean_dec(x_234); -x_252 = lean_box(0); -x_8 = x_252; -goto block_233; +lean_object* x_240; +x_240 = lean_box(0); +x_8 = x_240; +goto block_214; } } else { -lean_object* x_253; lean_object* x_254; lean_object* x_255; -lean_dec(x_234); +lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_dec(x_4); -x_253 = lean_ctor_get(x_5, 1); -lean_inc(x_253); -x_254 = lean_array_uget(x_253, x_7); -lean_dec(x_253); -x_255 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_255, 0, x_254); -lean_ctor_set(x_255, 1, x_5); -return x_255; +x_241 = lean_ctor_get(x_5, 1); +lean_inc(x_241); +x_242 = lean_array_uget(x_241, x_7); +lean_dec(x_241); +x_243 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_243, 0, x_242); +lean_ctor_set(x_243, 1, x_5); +return x_243; } -block_233: +block_214: { lean_dec(x_8); switch (lean_obj_tag(x_4)) { @@ -5296,702 +5190,619 @@ 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_15, 0); x_18 = lean_ctor_get(x_15, 1); -x_19 = lean_ctor_get(x_18, 0); -lean_inc(x_19); -lean_inc(x_4); -x_20 = lean_array_uset(x_19, x_7, x_4); -x_21 = !lean_is_exclusive(x_4); +x_19 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_19, 0, x_9); +lean_ctor_set(x_19, 1, x_10); +lean_ctor_set_uint64(x_19, sizeof(void*)*2, x_11); +x_20 = lean_expr_update_app(x_19, x_13, x_17); +x_21 = !lean_is_exclusive(x_18); 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; -x_22 = lean_ctor_get(x_4, 1); -lean_dec(x_22); -x_23 = lean_ctor_get(x_4, 0); -lean_dec(x_23); -x_24 = lean_ctor_get(x_18, 1); -lean_inc(x_24); -lean_dec(x_18); -x_25 = lean_expr_update_app(x_4, x_13, x_17); -lean_inc(x_25); -x_26 = lean_array_uset(x_24, x_7, x_25); -x_27 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_27, 0, x_20); -lean_ctor_set(x_27, 1, x_26); -lean_ctor_set(x_15, 1, x_27); -lean_ctor_set(x_15, 0, x_25); +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_22 = lean_ctor_get(x_18, 0); +x_23 = lean_ctor_get(x_18, 1); +x_24 = lean_array_uset(x_22, x_7, x_4); +lean_inc(x_20); +x_25 = lean_array_uset(x_23, x_7, x_20); +lean_ctor_set(x_18, 1, x_25); +lean_ctor_set(x_18, 0, x_24); +lean_ctor_set(x_15, 0, x_20); return x_15; } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; -lean_dec(x_4); -x_28 = lean_ctor_get(x_18, 1); -lean_inc(x_28); +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_26 = lean_ctor_get(x_18, 0); +x_27 = lean_ctor_get(x_18, 1); +lean_inc(x_27); +lean_inc(x_26); lean_dec(x_18); -x_29 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_29, 0, x_9); -lean_ctor_set(x_29, 1, x_10); -lean_ctor_set_uint64(x_29, sizeof(void*)*2, x_11); -x_30 = lean_expr_update_app(x_29, x_13, x_17); -lean_inc(x_30); -x_31 = lean_array_uset(x_28, x_7, x_30); -x_32 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_32, 0, x_20); -lean_ctor_set(x_32, 1, x_31); -lean_ctor_set(x_15, 1, x_32); -lean_ctor_set(x_15, 0, x_30); +x_28 = lean_array_uset(x_26, x_7, x_4); +lean_inc(x_20); +x_29 = lean_array_uset(x_27, x_7, x_20); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_28); +lean_ctor_set(x_30, 1, x_29); +lean_ctor_set(x_15, 1, x_30); +lean_ctor_set(x_15, 0, x_20); return x_15; } } 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; 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_15, 0); -x_34 = lean_ctor_get(x_15, 1); -lean_inc(x_34); -lean_inc(x_33); +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_31 = lean_ctor_get(x_15, 0); +x_32 = lean_ctor_get(x_15, 1); +lean_inc(x_32); +lean_inc(x_31); lean_dec(x_15); -x_35 = lean_ctor_get(x_34, 0); +x_33 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_33, 0, x_9); +lean_ctor_set(x_33, 1, x_10); +lean_ctor_set_uint64(x_33, sizeof(void*)*2, x_11); +x_34 = lean_expr_update_app(x_33, x_13, x_31); +x_35 = lean_ctor_get(x_32, 0); lean_inc(x_35); -lean_inc(x_4); -x_36 = lean_array_uset(x_35, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - x_37 = x_4; +x_36 = lean_ctor_get(x_32, 1); +lean_inc(x_36); +if (lean_is_exclusive(x_32)) { + lean_ctor_release(x_32, 0); + lean_ctor_release(x_32, 1); + x_37 = x_32; } else { - lean_dec_ref(x_4); + lean_dec_ref(x_32); x_37 = lean_box(0); } -x_38 = lean_ctor_get(x_34, 1); -lean_inc(x_38); -lean_dec(x_34); +x_38 = lean_array_uset(x_35, x_7, x_4); +lean_inc(x_34); +x_39 = lean_array_uset(x_36, x_7, x_34); if (lean_is_scalar(x_37)) { - x_39 = lean_alloc_ctor(5, 2, 8); + x_40 = lean_alloc_ctor(0, 2, 0); } else { - x_39 = x_37; + x_40 = x_37; } -lean_ctor_set(x_39, 0, x_9); -lean_ctor_set(x_39, 1, x_10); -lean_ctor_set_uint64(x_39, sizeof(void*)*2, x_11); -x_40 = lean_expr_update_app(x_39, x_13, x_33); -lean_inc(x_40); -x_41 = lean_array_uset(x_38, x_7, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_36); -lean_ctor_set(x_42, 1, x_41); -x_43 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_43, 0, x_40); -lean_ctor_set(x_43, 1, x_42); -return x_43; +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +x_41 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 0, x_34); +lean_ctor_set(x_41, 1, x_40); +return x_41; } } case 6: { -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_object* x_50; lean_object* x_51; uint8_t x_52; -x_44 = lean_ctor_get(x_4, 0); +lean_object* x_42; lean_object* x_43; lean_object* x_44; uint64_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +x_42 = lean_ctor_get(x_4, 0); +lean_inc(x_42); +x_43 = lean_ctor_get(x_4, 1); +lean_inc(x_43); +x_44 = lean_ctor_get(x_4, 2); lean_inc(x_44); -x_45 = lean_ctor_get(x_4, 1); -lean_inc(x_45); -x_46 = lean_ctor_get(x_4, 2); -lean_inc(x_46); -x_47 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_45); -x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_45, x_5); -x_49 = lean_ctor_get(x_48, 0); -lean_inc(x_49); -x_50 = lean_ctor_get(x_48, 1); -lean_inc(x_50); -lean_dec(x_48); -lean_inc(x_46); -x_51 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_46, x_50); -x_52 = !lean_is_exclusive(x_51); -if (x_52 == 0) +x_45 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_43); +x_46 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_43, x_5); +x_47 = lean_ctor_get(x_46, 0); +lean_inc(x_47); +x_48 = lean_ctor_get(x_46, 1); +lean_inc(x_48); +lean_dec(x_46); +lean_inc(x_44); +x_49 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_44, x_48); +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; -x_53 = lean_ctor_get(x_51, 0); -x_54 = lean_ctor_get(x_51, 1); -x_55 = lean_ctor_get(x_54, 0); +lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; uint8_t x_56; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +x_53 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_53, 0, x_42); +lean_ctor_set(x_53, 1, x_43); +lean_ctor_set(x_53, 2, x_44); +lean_ctor_set_uint64(x_53, sizeof(void*)*3, x_45); +x_54 = (uint8_t)((x_45 << 24) >> 61); +x_55 = lean_expr_update_lambda(x_53, x_54, x_47, x_51); +x_56 = !lean_is_exclusive(x_52); +if (x_56 == 0) +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_57 = lean_ctor_get(x_52, 0); +x_58 = lean_ctor_get(x_52, 1); +x_59 = lean_array_uset(x_57, x_7, x_4); lean_inc(x_55); -lean_inc(x_4); -x_56 = lean_array_uset(x_55, x_7, x_4); -x_57 = !lean_is_exclusive(x_4); -if (x_57 == 0) +x_60 = lean_array_uset(x_58, x_7, x_55); +lean_ctor_set(x_52, 1, x_60); +lean_ctor_set(x_52, 0, x_59); +lean_ctor_set(x_49, 0, x_55); +return x_49; +} +else { -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_58 = lean_ctor_get(x_4, 2); -lean_dec(x_58); -x_59 = lean_ctor_get(x_4, 1); -lean_dec(x_59); -x_60 = lean_ctor_get(x_4, 0); -lean_dec(x_60); -x_61 = lean_ctor_get(x_54, 1); +lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_61 = lean_ctor_get(x_52, 0); +x_62 = lean_ctor_get(x_52, 1); +lean_inc(x_62); lean_inc(x_61); -lean_dec(x_54); -x_62 = (uint8_t)((x_47 << 24) >> 61); -x_63 = lean_expr_update_lambda(x_4, x_62, x_49, x_53); -lean_inc(x_63); -x_64 = lean_array_uset(x_61, x_7, x_63); +lean_dec(x_52); +x_63 = lean_array_uset(x_61, x_7, x_4); +lean_inc(x_55); +x_64 = lean_array_uset(x_62, x_7, x_55); x_65 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_65, 0, x_56); +lean_ctor_set(x_65, 0, x_63); lean_ctor_set(x_65, 1, x_64); -lean_ctor_set(x_51, 1, x_65); -lean_ctor_set(x_51, 0, x_63); -return x_51; +lean_ctor_set(x_49, 1, x_65); +lean_ctor_set(x_49, 0, x_55); +return x_49; +} } else { -lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; -lean_dec(x_4); -x_66 = lean_ctor_get(x_54, 1); +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; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_66 = lean_ctor_get(x_49, 0); +x_67 = lean_ctor_get(x_49, 1); +lean_inc(x_67); lean_inc(x_66); -lean_dec(x_54); -x_67 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_67, 0, x_44); -lean_ctor_set(x_67, 1, x_45); -lean_ctor_set(x_67, 2, x_46); -lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_47); -x_68 = (uint8_t)((x_47 << 24) >> 61); -x_69 = lean_expr_update_lambda(x_67, x_68, x_49, x_53); -lean_inc(x_69); -x_70 = lean_array_uset(x_66, x_7, x_69); -x_71 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_71, 0, x_56); -lean_ctor_set(x_71, 1, x_70); -lean_ctor_set(x_51, 1, x_71); -lean_ctor_set(x_51, 0, x_69); -return x_51; -} -} -else -{ -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_72 = lean_ctor_get(x_51, 0); -x_73 = lean_ctor_get(x_51, 1); -lean_inc(x_73); +lean_dec(x_49); +x_68 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_68, 0, x_42); +lean_ctor_set(x_68, 1, x_43); +lean_ctor_set(x_68, 2, x_44); +lean_ctor_set_uint64(x_68, sizeof(void*)*3, x_45); +x_69 = (uint8_t)((x_45 << 24) >> 61); +x_70 = lean_expr_update_lambda(x_68, x_69, x_47, x_66); +x_71 = lean_ctor_get(x_67, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_67, 1); lean_inc(x_72); -lean_dec(x_51); -x_74 = lean_ctor_get(x_73, 0); -lean_inc(x_74); -lean_inc(x_4); -x_75 = lean_array_uset(x_74, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_76 = x_4; +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_73 = x_67; } else { - lean_dec_ref(x_4); - x_76 = lean_box(0); + lean_dec_ref(x_67); + x_73 = lean_box(0); } -x_77 = lean_ctor_get(x_73, 1); -lean_inc(x_77); -lean_dec(x_73); -if (lean_is_scalar(x_76)) { - x_78 = lean_alloc_ctor(6, 3, 8); +x_74 = lean_array_uset(x_71, x_7, x_4); +lean_inc(x_70); +x_75 = lean_array_uset(x_72, x_7, x_70); +if (lean_is_scalar(x_73)) { + x_76 = lean_alloc_ctor(0, 2, 0); } else { - x_78 = x_76; + x_76 = x_73; } -lean_ctor_set(x_78, 0, x_44); -lean_ctor_set(x_78, 1, x_45); -lean_ctor_set(x_78, 2, x_46); -lean_ctor_set_uint64(x_78, sizeof(void*)*3, x_47); -x_79 = (uint8_t)((x_47 << 24) >> 61); -x_80 = lean_expr_update_lambda(x_78, x_79, x_49, x_72); -lean_inc(x_80); -x_81 = lean_array_uset(x_77, x_7, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_75); -lean_ctor_set(x_82, 1, x_81); -x_83 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_83, 0, x_80); -lean_ctor_set(x_83, 1, x_82); -return x_83; +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +x_77 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_77, 0, x_70); +lean_ctor_set(x_77, 1, x_76); +return x_77; } } case 7: { -lean_object* x_84; lean_object* x_85; lean_object* x_86; uint64_t x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; uint8_t x_92; -x_84 = lean_ctor_get(x_4, 0); +lean_object* x_78; lean_object* x_79; lean_object* x_80; uint64_t x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; uint8_t x_86; +x_78 = lean_ctor_get(x_4, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_4, 1); +lean_inc(x_79); +x_80 = lean_ctor_get(x_4, 2); +lean_inc(x_80); +x_81 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_79); +x_82 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_79, x_5); +x_83 = lean_ctor_get(x_82, 0); +lean_inc(x_83); +x_84 = lean_ctor_get(x_82, 1); lean_inc(x_84); -x_85 = lean_ctor_get(x_4, 1); -lean_inc(x_85); -x_86 = lean_ctor_get(x_4, 2); -lean_inc(x_86); -x_87 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_85); -x_88 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_85, x_5); -x_89 = lean_ctor_get(x_88, 0); -lean_inc(x_89); -x_90 = lean_ctor_get(x_88, 1); -lean_inc(x_90); -lean_dec(x_88); -lean_inc(x_86); -x_91 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_86, x_90); -x_92 = !lean_is_exclusive(x_91); +lean_dec(x_82); +lean_inc(x_80); +x_85 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_80, x_84); +x_86 = !lean_is_exclusive(x_85); +if (x_86 == 0) +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; uint8_t x_90; lean_object* x_91; uint8_t x_92; +x_87 = lean_ctor_get(x_85, 0); +x_88 = lean_ctor_get(x_85, 1); +x_89 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_89, 0, x_78); +lean_ctor_set(x_89, 1, x_79); +lean_ctor_set(x_89, 2, x_80); +lean_ctor_set_uint64(x_89, sizeof(void*)*3, x_81); +x_90 = (uint8_t)((x_81 << 24) >> 61); +x_91 = lean_expr_update_forall(x_89, x_90, x_83, x_87); +x_92 = !lean_is_exclusive(x_88); if (x_92 == 0) { -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; uint8_t x_97; -x_93 = lean_ctor_get(x_91, 0); -x_94 = lean_ctor_get(x_91, 1); -x_95 = lean_ctor_get(x_94, 0); -lean_inc(x_95); -lean_inc(x_4); -x_96 = lean_array_uset(x_95, x_7, x_4); -x_97 = !lean_is_exclusive(x_4); -if (x_97 == 0) +lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_93 = lean_ctor_get(x_88, 0); +x_94 = lean_ctor_get(x_88, 1); +x_95 = lean_array_uset(x_93, x_7, x_4); +lean_inc(x_91); +x_96 = lean_array_uset(x_94, x_7, x_91); +lean_ctor_set(x_88, 1, x_96); +lean_ctor_set(x_88, 0, x_95); +lean_ctor_set(x_85, 0, x_91); +return x_85; +} +else { -lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; -x_98 = lean_ctor_get(x_4, 2); -lean_dec(x_98); -x_99 = lean_ctor_get(x_4, 1); -lean_dec(x_99); -x_100 = lean_ctor_get(x_4, 0); -lean_dec(x_100); -x_101 = lean_ctor_get(x_94, 1); -lean_inc(x_101); -lean_dec(x_94); -x_102 = (uint8_t)((x_87 << 24) >> 61); -x_103 = lean_expr_update_forall(x_4, x_102, x_89, x_93); +lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_97 = lean_ctor_get(x_88, 0); +x_98 = lean_ctor_get(x_88, 1); +lean_inc(x_98); +lean_inc(x_97); +lean_dec(x_88); +x_99 = lean_array_uset(x_97, x_7, x_4); +lean_inc(x_91); +x_100 = lean_array_uset(x_98, x_7, x_91); +x_101 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +lean_ctor_set(x_85, 1, x_101); +lean_ctor_set(x_85, 0, x_91); +return x_85; +} +} +else +{ +lean_object* x_102; lean_object* x_103; lean_object* x_104; uint8_t 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; +x_102 = lean_ctor_get(x_85, 0); +x_103 = lean_ctor_get(x_85, 1); lean_inc(x_103); -x_104 = lean_array_uset(x_101, x_7, x_103); -x_105 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_105, 0, x_96); -lean_ctor_set(x_105, 1, x_104); -lean_ctor_set(x_91, 1, x_105); -lean_ctor_set(x_91, 0, x_103); -return x_91; +lean_inc(x_102); +lean_dec(x_85); +x_104 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_104, 0, x_78); +lean_ctor_set(x_104, 1, x_79); +lean_ctor_set(x_104, 2, x_80); +lean_ctor_set_uint64(x_104, sizeof(void*)*3, x_81); +x_105 = (uint8_t)((x_81 << 24) >> 61); +x_106 = lean_expr_update_forall(x_104, x_105, x_83, x_102); +x_107 = lean_ctor_get(x_103, 0); +lean_inc(x_107); +x_108 = lean_ctor_get(x_103, 1); +lean_inc(x_108); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); + x_109 = x_103; +} else { + lean_dec_ref(x_103); + x_109 = lean_box(0); } -else -{ -lean_object* x_106; lean_object* x_107; uint8_t x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; -lean_dec(x_4); -x_106 = lean_ctor_get(x_94, 1); +x_110 = lean_array_uset(x_107, x_7, x_4); lean_inc(x_106); -lean_dec(x_94); -x_107 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_107, 0, x_84); -lean_ctor_set(x_107, 1, x_85); -lean_ctor_set(x_107, 2, x_86); -lean_ctor_set_uint64(x_107, sizeof(void*)*3, x_87); -x_108 = (uint8_t)((x_87 << 24) >> 61); -x_109 = lean_expr_update_forall(x_107, x_108, x_89, x_93); -lean_inc(x_109); -x_110 = lean_array_uset(x_106, x_7, x_109); -x_111 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_111, 0, x_96); -lean_ctor_set(x_111, 1, x_110); -lean_ctor_set(x_91, 1, x_111); -lean_ctor_set(x_91, 0, x_109); -return x_91; -} -} -else -{ -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; lean_object* x_121; lean_object* x_122; lean_object* x_123; -x_112 = lean_ctor_get(x_91, 0); -x_113 = lean_ctor_get(x_91, 1); -lean_inc(x_113); -lean_inc(x_112); -lean_dec(x_91); -x_114 = lean_ctor_get(x_113, 0); -lean_inc(x_114); -lean_inc(x_4); -x_115 = lean_array_uset(x_114, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_116 = x_4; +x_111 = lean_array_uset(x_108, x_7, x_106); +if (lean_is_scalar(x_109)) { + x_112 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_4); - x_116 = lean_box(0); + x_112 = x_109; } -x_117 = lean_ctor_get(x_113, 1); -lean_inc(x_117); -lean_dec(x_113); -if (lean_is_scalar(x_116)) { - x_118 = lean_alloc_ctor(7, 3, 8); -} else { - x_118 = x_116; -} -lean_ctor_set(x_118, 0, x_84); -lean_ctor_set(x_118, 1, x_85); -lean_ctor_set(x_118, 2, x_86); -lean_ctor_set_uint64(x_118, sizeof(void*)*3, x_87); -x_119 = (uint8_t)((x_87 << 24) >> 61); -x_120 = lean_expr_update_forall(x_118, x_119, x_89, x_112); -lean_inc(x_120); -x_121 = lean_array_uset(x_117, x_7, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_115); -lean_ctor_set(x_122, 1, x_121); -x_123 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_123, 0, x_120); -lean_ctor_set(x_123, 1, x_122); -return x_123; +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +x_113 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_113, 0, x_106); +lean_ctor_set(x_113, 1, x_112); +return x_113; } } case 8: { -lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; uint64_t 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; uint8_t x_136; -x_124 = lean_ctor_get(x_4, 0); +lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; uint64_t 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; +x_114 = lean_ctor_get(x_4, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_4, 1); +lean_inc(x_115); +x_116 = lean_ctor_get(x_4, 2); +lean_inc(x_116); +x_117 = lean_ctor_get(x_4, 3); +lean_inc(x_117); +x_118 = lean_ctor_get_uint64(x_4, sizeof(void*)*4); +lean_inc(x_115); +x_119 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_115, x_5); +x_120 = lean_ctor_get(x_119, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_119, 1); +lean_inc(x_121); +lean_dec(x_119); +lean_inc(x_116); +x_122 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_116, x_121); +x_123 = lean_ctor_get(x_122, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_122, 1); lean_inc(x_124); -x_125 = lean_ctor_get(x_4, 1); -lean_inc(x_125); -x_126 = lean_ctor_get(x_4, 2); -lean_inc(x_126); -x_127 = lean_ctor_get(x_4, 3); -lean_inc(x_127); -x_128 = lean_ctor_get_uint64(x_4, sizeof(void*)*4); -lean_inc(x_125); -x_129 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_125, x_5); -x_130 = lean_ctor_get(x_129, 0); +lean_dec(x_122); +lean_inc(x_117); +x_125 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_117, x_124); +x_126 = !lean_is_exclusive(x_125); +if (x_126 == 0) +{ +lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint8_t x_131; +x_127 = lean_ctor_get(x_125, 0); +x_128 = lean_ctor_get(x_125, 1); +x_129 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_129, 0, x_114); +lean_ctor_set(x_129, 1, x_115); +lean_ctor_set(x_129, 2, x_116); +lean_ctor_set(x_129, 3, x_117); +lean_ctor_set_uint64(x_129, sizeof(void*)*4, x_118); +x_130 = lean_expr_update_let(x_129, x_120, x_123, x_127); +x_131 = !lean_is_exclusive(x_128); +if (x_131 == 0) +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; +x_132 = lean_ctor_get(x_128, 0); +x_133 = lean_ctor_get(x_128, 1); +x_134 = lean_array_uset(x_132, x_7, x_4); lean_inc(x_130); -x_131 = lean_ctor_get(x_129, 1); -lean_inc(x_131); -lean_dec(x_129); -lean_inc(x_126); -x_132 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_126, x_131); -x_133 = lean_ctor_get(x_132, 0); -lean_inc(x_133); -x_134 = lean_ctor_get(x_132, 1); -lean_inc(x_134); -lean_dec(x_132); -lean_inc(x_127); -x_135 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_127, x_134); -x_136 = !lean_is_exclusive(x_135); -if (x_136 == 0) +x_135 = lean_array_uset(x_133, x_7, x_130); +lean_ctor_set(x_128, 1, x_135); +lean_ctor_set(x_128, 0, x_134); +lean_ctor_set(x_125, 0, x_130); +return x_125; +} +else { -lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; uint8_t x_141; -x_137 = lean_ctor_get(x_135, 0); -x_138 = lean_ctor_get(x_135, 1); -x_139 = lean_ctor_get(x_138, 0); -lean_inc(x_139); -lean_inc(x_4); -x_140 = lean_array_uset(x_139, x_7, x_4); -x_141 = !lean_is_exclusive(x_4); -if (x_141 == 0) +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_128, 0); +x_137 = lean_ctor_get(x_128, 1); +lean_inc(x_137); +lean_inc(x_136); +lean_dec(x_128); +x_138 = lean_array_uset(x_136, x_7, x_4); +lean_inc(x_130); +x_139 = lean_array_uset(x_137, x_7, x_130); +x_140 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_140, 0, x_138); +lean_ctor_set(x_140, 1, x_139); +lean_ctor_set(x_125, 1, x_140); +lean_ctor_set(x_125, 0, x_130); +return x_125; +} +} +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; -x_142 = lean_ctor_get(x_4, 3); -lean_dec(x_142); -x_143 = lean_ctor_get(x_4, 2); -lean_dec(x_143); -x_144 = lean_ctor_get(x_4, 1); -lean_dec(x_144); -x_145 = lean_ctor_get(x_4, 0); -lean_dec(x_145); -x_146 = lean_ctor_get(x_138, 1); +lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; +x_141 = lean_ctor_get(x_125, 0); +x_142 = lean_ctor_get(x_125, 1); +lean_inc(x_142); +lean_inc(x_141); +lean_dec(x_125); +x_143 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_143, 0, x_114); +lean_ctor_set(x_143, 1, x_115); +lean_ctor_set(x_143, 2, x_116); +lean_ctor_set(x_143, 3, x_117); +lean_ctor_set_uint64(x_143, sizeof(void*)*4, x_118); +x_144 = lean_expr_update_let(x_143, x_120, x_123, x_141); +x_145 = lean_ctor_get(x_142, 0); +lean_inc(x_145); +x_146 = lean_ctor_get(x_142, 1); lean_inc(x_146); -lean_dec(x_138); -x_147 = lean_expr_update_let(x_4, x_130, x_133, x_137); -lean_inc(x_147); -x_148 = lean_array_uset(x_146, x_7, x_147); -x_149 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_149, 0, x_140); -lean_ctor_set(x_149, 1, x_148); -lean_ctor_set(x_135, 1, x_149); -lean_ctor_set(x_135, 0, x_147); -return x_135; -} -else -{ -lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; -lean_dec(x_4); -x_150 = lean_ctor_get(x_138, 1); -lean_inc(x_150); -lean_dec(x_138); -x_151 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_151, 0, x_124); -lean_ctor_set(x_151, 1, x_125); -lean_ctor_set(x_151, 2, x_126); -lean_ctor_set(x_151, 3, x_127); -lean_ctor_set_uint64(x_151, sizeof(void*)*4, x_128); -x_152 = lean_expr_update_let(x_151, x_130, x_133, x_137); -lean_inc(x_152); -x_153 = lean_array_uset(x_150, x_7, x_152); -x_154 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_154, 0, x_140); -lean_ctor_set(x_154, 1, x_153); -lean_ctor_set(x_135, 1, x_154); -lean_ctor_set(x_135, 0, x_152); -return x_135; -} -} -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; lean_object* x_164; lean_object* x_165; -x_155 = lean_ctor_get(x_135, 0); -x_156 = lean_ctor_get(x_135, 1); -lean_inc(x_156); -lean_inc(x_155); -lean_dec(x_135); -x_157 = lean_ctor_get(x_156, 0); -lean_inc(x_157); -lean_inc(x_4); -x_158 = lean_array_uset(x_157, x_7, x_4); -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_159 = x_4; +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_4); - x_159 = lean_box(0); + lean_dec_ref(x_142); + x_147 = lean_box(0); } -x_160 = lean_ctor_get(x_156, 1); -lean_inc(x_160); -lean_dec(x_156); -if (lean_is_scalar(x_159)) { - x_161 = lean_alloc_ctor(8, 4, 8); +x_148 = lean_array_uset(x_145, x_7, x_4); +lean_inc(x_144); +x_149 = lean_array_uset(x_146, x_7, x_144); +if (lean_is_scalar(x_147)) { + x_150 = lean_alloc_ctor(0, 2, 0); } else { - x_161 = x_159; + x_150 = x_147; } -lean_ctor_set(x_161, 0, x_124); -lean_ctor_set(x_161, 1, x_125); -lean_ctor_set(x_161, 2, x_126); -lean_ctor_set(x_161, 3, x_127); -lean_ctor_set_uint64(x_161, sizeof(void*)*4, x_128); -x_162 = lean_expr_update_let(x_161, x_130, x_133, x_155); -lean_inc(x_162); -x_163 = lean_array_uset(x_160, x_7, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_158); -lean_ctor_set(x_164, 1, x_163); -x_165 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_165, 0, x_162); -lean_ctor_set(x_165, 1, x_164); -return x_165; +lean_ctor_set(x_150, 0, x_148); +lean_ctor_set(x_150, 1, x_149); +x_151 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_151, 0, x_144); +lean_ctor_set(x_151, 1, x_150); +return x_151; } } case 10: { -lean_object* x_166; lean_object* x_167; uint64_t x_168; lean_object* x_169; uint8_t x_170; -x_166 = lean_ctor_get(x_4, 0); +lean_object* x_152; lean_object* x_153; uint64_t x_154; lean_object* x_155; uint8_t x_156; +x_152 = lean_ctor_get(x_4, 0); +lean_inc(x_152); +x_153 = lean_ctor_get(x_4, 1); +lean_inc(x_153); +x_154 = lean_ctor_get_uint64(x_4, sizeof(void*)*2); +lean_inc(x_153); +x_155 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_153, x_5); +x_156 = !lean_is_exclusive(x_155); +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_155, 0); +x_158 = lean_ctor_get(x_155, 1); +x_159 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_159, 0, x_152); +lean_ctor_set(x_159, 1, x_153); +lean_ctor_set_uint64(x_159, sizeof(void*)*2, x_154); +x_160 = lean_expr_update_mdata(x_159, x_157); +x_161 = !lean_is_exclusive(x_158); +if (x_161 == 0) +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; +x_162 = lean_ctor_get(x_158, 0); +x_163 = lean_ctor_get(x_158, 1); +x_164 = lean_array_uset(x_162, x_7, x_4); +lean_inc(x_160); +x_165 = lean_array_uset(x_163, x_7, x_160); +lean_ctor_set(x_158, 1, x_165); +lean_ctor_set(x_158, 0, x_164); +lean_ctor_set(x_155, 0, x_160); +return x_155; +} +else +{ +lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; +x_166 = lean_ctor_get(x_158, 0); +x_167 = lean_ctor_get(x_158, 1); +lean_inc(x_167); lean_inc(x_166); -x_167 = lean_ctor_get(x_4, 1); -lean_inc(x_167); -x_168 = lean_ctor_get_uint64(x_4, sizeof(void*)*2); -lean_inc(x_167); -x_169 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_167, x_5); -x_170 = !lean_is_exclusive(x_169); -if (x_170 == 0) +lean_dec(x_158); +x_168 = lean_array_uset(x_166, x_7, x_4); +lean_inc(x_160); +x_169 = lean_array_uset(x_167, x_7, x_160); +x_170 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_170, 0, x_168); +lean_ctor_set(x_170, 1, x_169); +lean_ctor_set(x_155, 1, x_170); +lean_ctor_set(x_155, 0, x_160); +return x_155; +} +} +else { -lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; -x_171 = lean_ctor_get(x_169, 0); -x_172 = lean_ctor_get(x_169, 1); -x_173 = lean_ctor_get(x_172, 0); -lean_inc(x_173); -lean_inc(x_4); -x_174 = lean_array_uset(x_173, x_7, x_4); -x_175 = !lean_is_exclusive(x_4); -if (x_175 == 0) -{ -lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; -x_176 = lean_ctor_get(x_4, 1); -lean_dec(x_176); -x_177 = lean_ctor_get(x_4, 0); -lean_dec(x_177); -x_178 = lean_ctor_get(x_172, 1); -lean_inc(x_178); -lean_dec(x_172); -x_179 = lean_expr_update_mdata(x_4, x_171); -lean_inc(x_179); -x_180 = lean_array_uset(x_178, x_7, x_179); +lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_171 = lean_ctor_get(x_155, 0); +x_172 = lean_ctor_get(x_155, 1); +lean_inc(x_172); +lean_inc(x_171); +lean_dec(x_155); +x_173 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_173, 0, x_152); +lean_ctor_set(x_173, 1, x_153); +lean_ctor_set_uint64(x_173, sizeof(void*)*2, x_154); +x_174 = lean_expr_update_mdata(x_173, x_171); +x_175 = lean_ctor_get(x_172, 0); +lean_inc(x_175); +x_176 = lean_ctor_get(x_172, 1); +lean_inc(x_176); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_177 = x_172; +} else { + lean_dec_ref(x_172); + x_177 = lean_box(0); +} +x_178 = lean_array_uset(x_175, x_7, x_4); +lean_inc(x_174); +x_179 = lean_array_uset(x_176, x_7, x_174); +if (lean_is_scalar(x_177)) { + x_180 = lean_alloc_ctor(0, 2, 0); +} else { + x_180 = x_177; +} +lean_ctor_set(x_180, 0, x_178); +lean_ctor_set(x_180, 1, x_179); x_181 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_181, 0, x_174); lean_ctor_set(x_181, 1, x_180); -lean_ctor_set(x_169, 1, x_181); -lean_ctor_set(x_169, 0, x_179); -return x_169; -} -else -{ -lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; -lean_dec(x_4); -x_182 = lean_ctor_get(x_172, 1); -lean_inc(x_182); -lean_dec(x_172); -x_183 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_183, 0, x_166); -lean_ctor_set(x_183, 1, x_167); -lean_ctor_set_uint64(x_183, sizeof(void*)*2, x_168); -x_184 = lean_expr_update_mdata(x_183, x_171); -lean_inc(x_184); -x_185 = lean_array_uset(x_182, x_7, x_184); -x_186 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_186, 0, x_174); -lean_ctor_set(x_186, 1, x_185); -lean_ctor_set(x_169, 1, x_186); -lean_ctor_set(x_169, 0, x_184); -return x_169; -} -} -else -{ -lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; -x_187 = lean_ctor_get(x_169, 0); -x_188 = lean_ctor_get(x_169, 1); -lean_inc(x_188); -lean_inc(x_187); -lean_dec(x_169); -x_189 = lean_ctor_get(x_188, 0); -lean_inc(x_189); -lean_inc(x_4); -x_190 = lean_array_uset(x_189, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - x_191 = x_4; -} else { - lean_dec_ref(x_4); - x_191 = lean_box(0); -} -x_192 = lean_ctor_get(x_188, 1); -lean_inc(x_192); -lean_dec(x_188); -if (lean_is_scalar(x_191)) { - x_193 = lean_alloc_ctor(10, 2, 8); -} else { - x_193 = x_191; -} -lean_ctor_set(x_193, 0, x_166); -lean_ctor_set(x_193, 1, x_167); -lean_ctor_set_uint64(x_193, sizeof(void*)*2, x_168); -x_194 = lean_expr_update_mdata(x_193, x_187); -lean_inc(x_194); -x_195 = lean_array_uset(x_192, x_7, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_190); -lean_ctor_set(x_196, 1, x_195); -x_197 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_197, 0, x_194); -lean_ctor_set(x_197, 1, x_196); -return x_197; +return x_181; } } case 11: { -lean_object* x_198; lean_object* x_199; lean_object* x_200; uint64_t x_201; lean_object* x_202; uint8_t x_203; -x_198 = lean_ctor_get(x_4, 0); +lean_object* x_182; lean_object* x_183; lean_object* x_184; uint64_t x_185; lean_object* x_186; uint8_t x_187; +x_182 = lean_ctor_get(x_4, 0); +lean_inc(x_182); +x_183 = lean_ctor_get(x_4, 1); +lean_inc(x_183); +x_184 = lean_ctor_get(x_4, 2); +lean_inc(x_184); +x_185 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); +lean_inc(x_184); +x_186 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_184, x_5); +x_187 = !lean_is_exclusive(x_186); +if (x_187 == 0) +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; uint8_t x_192; +x_188 = lean_ctor_get(x_186, 0); +x_189 = lean_ctor_get(x_186, 1); +x_190 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_190, 0, x_182); +lean_ctor_set(x_190, 1, x_183); +lean_ctor_set(x_190, 2, x_184); +lean_ctor_set_uint64(x_190, sizeof(void*)*3, x_185); +x_191 = lean_expr_update_proj(x_190, x_188); +x_192 = !lean_is_exclusive(x_189); +if (x_192 == 0) +{ +lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; +x_193 = lean_ctor_get(x_189, 0); +x_194 = lean_ctor_get(x_189, 1); +x_195 = lean_array_uset(x_193, x_7, x_4); +lean_inc(x_191); +x_196 = lean_array_uset(x_194, x_7, x_191); +lean_ctor_set(x_189, 1, x_196); +lean_ctor_set(x_189, 0, x_195); +lean_ctor_set(x_186, 0, x_191); +return x_186; +} +else +{ +lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; +x_197 = lean_ctor_get(x_189, 0); +x_198 = lean_ctor_get(x_189, 1); lean_inc(x_198); -x_199 = lean_ctor_get(x_4, 1); -lean_inc(x_199); -x_200 = lean_ctor_get(x_4, 2); -lean_inc(x_200); -x_201 = lean_ctor_get_uint64(x_4, sizeof(void*)*3); -lean_inc(x_200); -x_202 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Elab_addAndCompilePartialRec___spec__1(x_1, x_2, x_3, x_200, x_5); -x_203 = !lean_is_exclusive(x_202); -if (x_203 == 0) +lean_inc(x_197); +lean_dec(x_189); +x_199 = lean_array_uset(x_197, x_7, x_4); +lean_inc(x_191); +x_200 = lean_array_uset(x_198, x_7, x_191); +x_201 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_201, 0, x_199); +lean_ctor_set(x_201, 1, x_200); +lean_ctor_set(x_186, 1, x_201); +lean_ctor_set(x_186, 0, x_191); +return x_186; +} +} +else { -lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; uint8_t x_208; -x_204 = lean_ctor_get(x_202, 0); -x_205 = lean_ctor_get(x_202, 1); -x_206 = lean_ctor_get(x_205, 0); +lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; +x_202 = lean_ctor_get(x_186, 0); +x_203 = lean_ctor_get(x_186, 1); +lean_inc(x_203); +lean_inc(x_202); +lean_dec(x_186); +x_204 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_204, 0, x_182); +lean_ctor_set(x_204, 1, x_183); +lean_ctor_set(x_204, 2, x_184); +lean_ctor_set_uint64(x_204, sizeof(void*)*3, x_185); +x_205 = lean_expr_update_proj(x_204, x_202); +x_206 = lean_ctor_get(x_203, 0); lean_inc(x_206); -lean_inc(x_4); -x_207 = lean_array_uset(x_206, x_7, x_4); -x_208 = !lean_is_exclusive(x_4); -if (x_208 == 0) -{ -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; -x_209 = lean_ctor_get(x_4, 2); -lean_dec(x_209); -x_210 = lean_ctor_get(x_4, 1); -lean_dec(x_210); -x_211 = lean_ctor_get(x_4, 0); -lean_dec(x_211); -x_212 = lean_ctor_get(x_205, 1); -lean_inc(x_212); -lean_dec(x_205); -x_213 = lean_expr_update_proj(x_4, x_204); -lean_inc(x_213); -x_214 = lean_array_uset(x_212, x_7, x_213); -x_215 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_215, 0, x_207); -lean_ctor_set(x_215, 1, x_214); -lean_ctor_set(x_202, 1, x_215); -lean_ctor_set(x_202, 0, x_213); -return x_202; -} -else -{ -lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; -lean_dec(x_4); -x_216 = lean_ctor_get(x_205, 1); -lean_inc(x_216); -lean_dec(x_205); -x_217 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_217, 0, x_198); -lean_ctor_set(x_217, 1, x_199); -lean_ctor_set(x_217, 2, x_200); -lean_ctor_set_uint64(x_217, sizeof(void*)*3, x_201); -x_218 = lean_expr_update_proj(x_217, x_204); -lean_inc(x_218); -x_219 = lean_array_uset(x_216, x_7, x_218); -x_220 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_220, 0, x_207); -lean_ctor_set(x_220, 1, x_219); -lean_ctor_set(x_202, 1, x_220); -lean_ctor_set(x_202, 0, x_218); -return x_202; -} -} -else -{ -lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; -x_221 = lean_ctor_get(x_202, 0); -x_222 = lean_ctor_get(x_202, 1); -lean_inc(x_222); -lean_inc(x_221); -lean_dec(x_202); -x_223 = lean_ctor_get(x_222, 0); -lean_inc(x_223); -lean_inc(x_4); -x_224 = lean_array_uset(x_223, x_7, x_4); -if (lean_is_exclusive(x_4)) { - lean_ctor_release(x_4, 0); - lean_ctor_release(x_4, 1); - lean_ctor_release(x_4, 2); - x_225 = x_4; +x_207 = lean_ctor_get(x_203, 1); +lean_inc(x_207); +if (lean_is_exclusive(x_203)) { + lean_ctor_release(x_203, 0); + lean_ctor_release(x_203, 1); + x_208 = x_203; } else { - lean_dec_ref(x_4); - x_225 = lean_box(0); + lean_dec_ref(x_203); + x_208 = lean_box(0); } -x_226 = lean_ctor_get(x_222, 1); -lean_inc(x_226); -lean_dec(x_222); -if (lean_is_scalar(x_225)) { - x_227 = lean_alloc_ctor(11, 3, 8); +x_209 = lean_array_uset(x_206, x_7, x_4); +lean_inc(x_205); +x_210 = lean_array_uset(x_207, x_7, x_205); +if (lean_is_scalar(x_208)) { + x_211 = lean_alloc_ctor(0, 2, 0); } else { - x_227 = x_225; + x_211 = x_208; } -lean_ctor_set(x_227, 0, x_198); -lean_ctor_set(x_227, 1, x_199); -lean_ctor_set(x_227, 2, x_200); -lean_ctor_set_uint64(x_227, sizeof(void*)*3, x_201); -x_228 = lean_expr_update_proj(x_227, x_221); -lean_inc(x_228); -x_229 = lean_array_uset(x_226, x_7, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_224); -lean_ctor_set(x_230, 1, x_229); -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_228); -lean_ctor_set(x_231, 1, x_230); -return x_231; +lean_ctor_set(x_211, 0, x_209); +lean_ctor_set(x_211, 1, x_210); +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_205); +lean_ctor_set(x_212, 1, x_211); +return x_212; } } default: { -lean_object* x_232; -x_232 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_232, 0, x_4); -lean_ctor_set(x_232, 1, x_5); -return x_232; +lean_object* x_213; +x_213 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_213, 0, x_4); +lean_ctor_set(x_213, 1, x_5); +return x_213; } } } diff --git a/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c b/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c index 9bd0272a8e..a6a5c81acb 100644 --- a/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c +++ b/stage0/stdlib/Lean/Meta/Match/MVarRenaming.c @@ -264,65 +264,64 @@ return x_2; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_233; lean_object* x_234; lean_object* x_241; size_t x_242; uint8_t x_243; +size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_214; lean_object* x_228; lean_object* x_229; size_t x_230; uint8_t x_231; x_5 = lean_ptr_addr(x_3); x_6 = x_2 == 0 ? x_5 : x_5 % x_2; -x_233 = lean_ctor_get(x_4, 0); -lean_inc(x_233); -x_241 = lean_array_uget(x_233, x_6); -x_242 = lean_ptr_addr(x_241); -lean_dec(x_241); -x_243 = x_242 == x_5; -if (x_243 == 0) +x_228 = lean_ctor_get(x_4, 0); +lean_inc(x_228); +x_229 = lean_array_uget(x_228, x_6); +lean_dec(x_228); +x_230 = lean_ptr_addr(x_229); +lean_dec(x_229); +x_231 = x_230 == x_5; +if (x_231 == 0) { if (lean_obj_tag(x_3) == 2) { -lean_object* x_244; lean_object* x_245; -x_244 = lean_ctor_get(x_3, 0); -lean_inc(x_244); -x_245 = l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_244); -lean_dec(x_244); -if (lean_obj_tag(x_245) == 0) +lean_object* x_232; lean_object* x_233; +x_232 = lean_ctor_get(x_3, 0); +lean_inc(x_232); +x_233 = l_Std_RBNode_find___at_Lean_Meta_MVarRenaming_find_x3f___spec__1(x_1, x_232); +lean_dec(x_232); +if (lean_obj_tag(x_233) == 0) { lean_inc(x_3); -x_234 = x_3; -goto block_240; +x_214 = x_3; +goto block_227; } else { -lean_object* x_246; lean_object* x_247; -x_246 = lean_ctor_get(x_245, 0); -lean_inc(x_246); -lean_dec(x_245); -x_247 = l_Lean_mkMVar(x_246); -x_234 = x_247; -goto block_240; -} -} -else -{ -lean_object* x_248; +lean_object* x_234; lean_object* x_235; +x_234 = lean_ctor_get(x_233, 0); +lean_inc(x_234); lean_dec(x_233); -x_248 = lean_box(0); -x_7 = x_248; -goto block_232; +x_235 = l_Lean_mkMVar(x_234); +x_214 = x_235; +goto block_227; } } else { -lean_object* x_249; lean_object* x_250; lean_object* x_251; -lean_dec(x_233); +lean_object* x_236; +x_236 = lean_box(0); +x_7 = x_236; +goto block_213; +} +} +else +{ +lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_dec(x_3); -x_249 = lean_ctor_get(x_4, 1); -lean_inc(x_249); -x_250 = lean_array_uget(x_249, x_6); -lean_dec(x_249); -x_251 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_251, 0, x_250); -lean_ctor_set(x_251, 1, x_4); -return x_251; +x_237 = lean_ctor_get(x_4, 1); +lean_inc(x_237); +x_238 = lean_array_uget(x_237, x_6); +lean_dec(x_237); +x_239 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_239, 0, x_238); +lean_ctor_set(x_239, 1, x_4); +return x_239; } -block_232: +block_213: { lean_dec(x_7); switch (lean_obj_tag(x_3)) { @@ -349,721 +348,660 @@ 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_14, 0); x_17 = lean_ctor_get(x_14, 1); -x_18 = lean_ctor_get(x_17, 0); -lean_inc(x_18); -lean_inc(x_3); -x_19 = lean_array_uset(x_18, x_6, x_3); -x_20 = !lean_is_exclusive(x_3); +x_18 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_18, 0, x_8); +lean_ctor_set(x_18, 1, x_9); +lean_ctor_set_uint64(x_18, sizeof(void*)*2, x_10); +x_19 = lean_expr_update_app(x_18, x_12, x_16); +x_20 = !lean_is_exclusive(x_17); if (x_20 == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -x_21 = lean_ctor_get(x_3, 1); -lean_dec(x_21); -x_22 = lean_ctor_get(x_3, 0); -lean_dec(x_22); -x_23 = lean_ctor_get(x_17, 1); -lean_inc(x_23); -lean_dec(x_17); -x_24 = lean_expr_update_app(x_3, x_12, x_16); -lean_inc(x_24); -x_25 = lean_array_uset(x_23, x_6, x_24); -x_26 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_26, 0, x_19); -lean_ctor_set(x_26, 1, x_25); -lean_ctor_set(x_14, 1, x_26); -lean_ctor_set(x_14, 0, x_24); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_17, 0); +x_22 = lean_ctor_get(x_17, 1); +x_23 = lean_array_uset(x_21, x_6, x_3); +lean_inc(x_19); +x_24 = lean_array_uset(x_22, x_6, x_19); +lean_ctor_set(x_17, 1, x_24); +lean_ctor_set(x_17, 0, x_23); +lean_ctor_set(x_14, 0, x_19); return x_14; } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_3); -x_27 = lean_ctor_get(x_17, 1); -lean_inc(x_27); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_17, 0); +x_26 = lean_ctor_get(x_17, 1); +lean_inc(x_26); +lean_inc(x_25); lean_dec(x_17); -x_28 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_28, 0, x_8); -lean_ctor_set(x_28, 1, x_9); -lean_ctor_set_uint64(x_28, sizeof(void*)*2, x_10); -x_29 = lean_expr_update_app(x_28, x_12, x_16); -lean_inc(x_29); -x_30 = lean_array_uset(x_27, x_6, x_29); -x_31 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_31, 0, x_19); -lean_ctor_set(x_31, 1, x_30); -lean_ctor_set(x_14, 1, x_31); -lean_ctor_set(x_14, 0, x_29); +x_27 = lean_array_uset(x_25, x_6, x_3); +lean_inc(x_19); +x_28 = lean_array_uset(x_26, x_6, x_19); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_14, 1, x_29); +lean_ctor_set(x_14, 0, x_19); return x_14; } } 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_14, 0); -x_33 = lean_ctor_get(x_14, 1); -lean_inc(x_33); -lean_inc(x_32); +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_30 = lean_ctor_get(x_14, 0); +x_31 = lean_ctor_get(x_14, 1); +lean_inc(x_31); +lean_inc(x_30); lean_dec(x_14); -x_34 = lean_ctor_get(x_33, 0); +x_32 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_32, 0, x_8); +lean_ctor_set(x_32, 1, x_9); +lean_ctor_set_uint64(x_32, sizeof(void*)*2, x_10); +x_33 = lean_expr_update_app(x_32, x_12, x_30); +x_34 = lean_ctor_get(x_31, 0); lean_inc(x_34); -lean_inc(x_3); -x_35 = lean_array_uset(x_34, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_36 = x_3; +x_35 = lean_ctor_get(x_31, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_36 = x_31; } else { - lean_dec_ref(x_3); + lean_dec_ref(x_31); x_36 = lean_box(0); } -x_37 = lean_ctor_get(x_33, 1); -lean_inc(x_37); -lean_dec(x_33); +x_37 = lean_array_uset(x_34, x_6, x_3); +lean_inc(x_33); +x_38 = lean_array_uset(x_35, x_6, x_33); if (lean_is_scalar(x_36)) { - x_38 = lean_alloc_ctor(5, 2, 8); + x_39 = lean_alloc_ctor(0, 2, 0); } else { - x_38 = x_36; + x_39 = x_36; } -lean_ctor_set(x_38, 0, x_8); -lean_ctor_set(x_38, 1, x_9); -lean_ctor_set_uint64(x_38, sizeof(void*)*2, x_10); -x_39 = lean_expr_update_app(x_38, x_12, x_32); -lean_inc(x_39); -x_40 = lean_array_uset(x_37, x_6, x_39); -x_41 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_41, 0, x_35); -lean_ctor_set(x_41, 1, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_39); -lean_ctor_set(x_42, 1, x_41); -return x_42; +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_33); +lean_ctor_set(x_40, 1, x_39); +return x_40; } } case 6: { -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_object* x_49; lean_object* x_50; uint8_t x_51; -x_43 = lean_ctor_get(x_3, 0); +lean_object* x_41; lean_object* x_42; lean_object* x_43; uint64_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_41 = lean_ctor_get(x_3, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_3, 1); +lean_inc(x_42); +x_43 = lean_ctor_get(x_3, 2); lean_inc(x_43); -x_44 = lean_ctor_get(x_3, 1); -lean_inc(x_44); -x_45 = lean_ctor_get(x_3, 2); -lean_inc(x_45); -x_46 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_44); -x_47 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_44, x_4); -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); -lean_inc(x_49); -lean_dec(x_47); -lean_inc(x_45); -x_50 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_45, x_49); -x_51 = !lean_is_exclusive(x_50); -if (x_51 == 0) +x_44 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_42); +x_45 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_42, x_4); +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +lean_inc(x_43); +x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_43, x_47); +x_49 = !lean_is_exclusive(x_48); +if (x_49 == 0) { -lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; -x_52 = lean_ctor_get(x_50, 0); -x_53 = lean_ctor_get(x_50, 1); -x_54 = lean_ctor_get(x_53, 0); +lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; +x_50 = lean_ctor_get(x_48, 0); +x_51 = lean_ctor_get(x_48, 1); +x_52 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_52, 0, x_41); +lean_ctor_set(x_52, 1, x_42); +lean_ctor_set(x_52, 2, x_43); +lean_ctor_set_uint64(x_52, sizeof(void*)*3, x_44); +x_53 = (uint8_t)((x_44 << 24) >> 61); +x_54 = lean_expr_update_lambda(x_52, x_53, x_46, x_50); +x_55 = !lean_is_exclusive(x_51); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_51, 0); +x_57 = lean_ctor_get(x_51, 1); +x_58 = lean_array_uset(x_56, x_6, x_3); lean_inc(x_54); -lean_inc(x_3); -x_55 = lean_array_uset(x_54, x_6, x_3); -x_56 = !lean_is_exclusive(x_3); -if (x_56 == 0) +x_59 = lean_array_uset(x_57, x_6, x_54); +lean_ctor_set(x_51, 1, x_59); +lean_ctor_set(x_51, 0, x_58); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} +else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; -x_57 = lean_ctor_get(x_3, 2); -lean_dec(x_57); -x_58 = lean_ctor_get(x_3, 1); -lean_dec(x_58); -x_59 = lean_ctor_get(x_3, 0); -lean_dec(x_59); -x_60 = lean_ctor_get(x_53, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_60 = lean_ctor_get(x_51, 0); +x_61 = lean_ctor_get(x_51, 1); +lean_inc(x_61); lean_inc(x_60); -lean_dec(x_53); -x_61 = (uint8_t)((x_46 << 24) >> 61); -x_62 = lean_expr_update_lambda(x_3, x_61, x_48, x_52); -lean_inc(x_62); -x_63 = lean_array_uset(x_60, x_6, x_62); +lean_dec(x_51); +x_62 = lean_array_uset(x_60, x_6, x_3); +lean_inc(x_54); +x_63 = lean_array_uset(x_61, x_6, x_54); x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_55); +lean_ctor_set(x_64, 0, x_62); lean_ctor_set(x_64, 1, x_63); -lean_ctor_set(x_50, 1, x_64); -lean_ctor_set(x_50, 0, x_62); -return x_50; +lean_ctor_set(x_48, 1, x_64); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} } else { -lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; -lean_dec(x_3); -x_65 = lean_ctor_get(x_53, 1); +lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_65 = lean_ctor_get(x_48, 0); +x_66 = lean_ctor_get(x_48, 1); +lean_inc(x_66); lean_inc(x_65); -lean_dec(x_53); -x_66 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_66, 0, x_43); -lean_ctor_set(x_66, 1, x_44); -lean_ctor_set(x_66, 2, x_45); -lean_ctor_set_uint64(x_66, sizeof(void*)*3, x_46); -x_67 = (uint8_t)((x_46 << 24) >> 61); -x_68 = lean_expr_update_lambda(x_66, x_67, x_48, x_52); -lean_inc(x_68); -x_69 = lean_array_uset(x_65, x_6, x_68); -x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_55); -lean_ctor_set(x_70, 1, x_69); -lean_ctor_set(x_50, 1, x_70); -lean_ctor_set(x_50, 0, x_68); -return x_50; -} -} -else -{ -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_71 = lean_ctor_get(x_50, 0); -x_72 = lean_ctor_get(x_50, 1); -lean_inc(x_72); +lean_dec(x_48); +x_67 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_67, 0, x_41); +lean_ctor_set(x_67, 1, x_42); +lean_ctor_set(x_67, 2, x_43); +lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_44); +x_68 = (uint8_t)((x_44 << 24) >> 61); +x_69 = lean_expr_update_lambda(x_67, x_68, x_46, x_65); +x_70 = lean_ctor_get(x_66, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_66, 1); lean_inc(x_71); -lean_dec(x_50); -x_73 = lean_ctor_get(x_72, 0); -lean_inc(x_73); -lean_inc(x_3); -x_74 = lean_array_uset(x_73, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_75 = x_3; +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + lean_ctor_release(x_66, 1); + x_72 = x_66; } else { - lean_dec_ref(x_3); - x_75 = lean_box(0); + lean_dec_ref(x_66); + x_72 = lean_box(0); } -x_76 = lean_ctor_get(x_72, 1); -lean_inc(x_76); -lean_dec(x_72); -if (lean_is_scalar(x_75)) { - x_77 = lean_alloc_ctor(6, 3, 8); +x_73 = lean_array_uset(x_70, x_6, x_3); +lean_inc(x_69); +x_74 = lean_array_uset(x_71, x_6, x_69); +if (lean_is_scalar(x_72)) { + x_75 = lean_alloc_ctor(0, 2, 0); } else { - x_77 = x_75; + x_75 = x_72; } -lean_ctor_set(x_77, 0, x_43); -lean_ctor_set(x_77, 1, x_44); -lean_ctor_set(x_77, 2, x_45); -lean_ctor_set_uint64(x_77, sizeof(void*)*3, x_46); -x_78 = (uint8_t)((x_46 << 24) >> 61); -x_79 = lean_expr_update_lambda(x_77, x_78, x_48, x_71); -lean_inc(x_79); -x_80 = lean_array_uset(x_76, x_6, x_79); -x_81 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_81, 0, x_74); -lean_ctor_set(x_81, 1, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_79); -lean_ctor_set(x_82, 1, x_81); -return x_82; +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set(x_75, 1, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_69); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } case 7: { -lean_object* x_83; lean_object* x_84; lean_object* x_85; uint64_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; -x_83 = lean_ctor_get(x_3, 0); +lean_object* x_77; lean_object* x_78; lean_object* x_79; uint64_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; +x_77 = lean_ctor_get(x_3, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_3, 1); +lean_inc(x_78); +x_79 = lean_ctor_get(x_3, 2); +lean_inc(x_79); +x_80 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_78); +x_81 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_78, x_4); +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); lean_inc(x_83); -x_84 = lean_ctor_get(x_3, 1); -lean_inc(x_84); -x_85 = lean_ctor_get(x_3, 2); -lean_inc(x_85); -x_86 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_84); -x_87 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_84, x_4); -x_88 = lean_ctor_get(x_87, 0); -lean_inc(x_88); -x_89 = lean_ctor_get(x_87, 1); -lean_inc(x_89); -lean_dec(x_87); -lean_inc(x_85); -x_90 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_85, x_89); -x_91 = !lean_is_exclusive(x_90); +lean_dec(x_81); +lean_inc(x_79); +x_84 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_79, x_83); +x_85 = !lean_is_exclusive(x_84); +if (x_85 == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; uint8_t x_89; lean_object* x_90; uint8_t x_91; +x_86 = lean_ctor_get(x_84, 0); +x_87 = lean_ctor_get(x_84, 1); +x_88 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_88, 0, x_77); +lean_ctor_set(x_88, 1, x_78); +lean_ctor_set(x_88, 2, x_79); +lean_ctor_set_uint64(x_88, sizeof(void*)*3, x_80); +x_89 = (uint8_t)((x_80 << 24) >> 61); +x_90 = lean_expr_update_forall(x_88, x_89, x_82, x_86); +x_91 = !lean_is_exclusive(x_87); if (x_91 == 0) { -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; uint8_t x_96; -x_92 = lean_ctor_get(x_90, 0); -x_93 = lean_ctor_get(x_90, 1); -x_94 = lean_ctor_get(x_93, 0); -lean_inc(x_94); -lean_inc(x_3); -x_95 = lean_array_uset(x_94, x_6, x_3); -x_96 = !lean_is_exclusive(x_3); -if (x_96 == 0) +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_92 = lean_ctor_get(x_87, 0); +x_93 = lean_ctor_get(x_87, 1); +x_94 = lean_array_uset(x_92, x_6, x_3); +lean_inc(x_90); +x_95 = lean_array_uset(x_93, x_6, x_90); +lean_ctor_set(x_87, 1, x_95); +lean_ctor_set(x_87, 0, x_94); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_97 = lean_ctor_get(x_3, 2); -lean_dec(x_97); -x_98 = lean_ctor_get(x_3, 1); -lean_dec(x_98); -x_99 = lean_ctor_get(x_3, 0); -lean_dec(x_99); -x_100 = lean_ctor_get(x_93, 1); -lean_inc(x_100); -lean_dec(x_93); -x_101 = (uint8_t)((x_86 << 24) >> 61); -x_102 = lean_expr_update_forall(x_3, x_101, x_88, x_92); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_96 = lean_ctor_get(x_87, 0); +x_97 = lean_ctor_get(x_87, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_87); +x_98 = lean_array_uset(x_96, x_6, x_3); +lean_inc(x_90); +x_99 = lean_array_uset(x_97, x_6, x_90); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +lean_ctor_set(x_84, 1, x_100); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_101 = lean_ctor_get(x_84, 0); +x_102 = lean_ctor_get(x_84, 1); lean_inc(x_102); -x_103 = lean_array_uset(x_100, x_6, x_102); -x_104 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_104, 0, x_95); -lean_ctor_set(x_104, 1, x_103); -lean_ctor_set(x_90, 1, x_104); -lean_ctor_set(x_90, 0, x_102); -return x_90; +lean_inc(x_101); +lean_dec(x_84); +x_103 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_103, 0, x_77); +lean_ctor_set(x_103, 1, x_78); +lean_ctor_set(x_103, 2, x_79); +lean_ctor_set_uint64(x_103, sizeof(void*)*3, x_80); +x_104 = (uint8_t)((x_80 << 24) >> 61); +x_105 = lean_expr_update_forall(x_103, x_104, x_82, x_101); +x_106 = lean_ctor_get(x_102, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_102, 1); +lean_inc(x_107); +if (lean_is_exclusive(x_102)) { + lean_ctor_release(x_102, 0); + lean_ctor_release(x_102, 1); + x_108 = x_102; +} else { + lean_dec_ref(x_102); + x_108 = lean_box(0); } -else -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_3); -x_105 = lean_ctor_get(x_93, 1); +x_109 = lean_array_uset(x_106, x_6, x_3); lean_inc(x_105); -lean_dec(x_93); -x_106 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_106, 0, x_83); -lean_ctor_set(x_106, 1, x_84); -lean_ctor_set(x_106, 2, x_85); -lean_ctor_set_uint64(x_106, sizeof(void*)*3, x_86); -x_107 = (uint8_t)((x_86 << 24) >> 61); -x_108 = lean_expr_update_forall(x_106, x_107, x_88, x_92); -lean_inc(x_108); -x_109 = lean_array_uset(x_105, x_6, x_108); -x_110 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_110, 0, x_95); -lean_ctor_set(x_110, 1, x_109); -lean_ctor_set(x_90, 1, x_110); -lean_ctor_set(x_90, 0, x_108); -return x_90; -} -} -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; uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; -x_111 = lean_ctor_get(x_90, 0); -x_112 = lean_ctor_get(x_90, 1); -lean_inc(x_112); -lean_inc(x_111); -lean_dec(x_90); -x_113 = lean_ctor_get(x_112, 0); -lean_inc(x_113); -lean_inc(x_3); -x_114 = lean_array_uset(x_113, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_115 = x_3; +x_110 = lean_array_uset(x_107, x_6, x_105); +if (lean_is_scalar(x_108)) { + x_111 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_3); - x_115 = lean_box(0); + x_111 = x_108; } -x_116 = lean_ctor_get(x_112, 1); -lean_inc(x_116); -lean_dec(x_112); -if (lean_is_scalar(x_115)) { - x_117 = lean_alloc_ctor(7, 3, 8); -} else { - x_117 = x_115; -} -lean_ctor_set(x_117, 0, x_83); -lean_ctor_set(x_117, 1, x_84); -lean_ctor_set(x_117, 2, x_85); -lean_ctor_set_uint64(x_117, sizeof(void*)*3, x_86); -x_118 = (uint8_t)((x_86 << 24) >> 61); -x_119 = lean_expr_update_forall(x_117, x_118, x_88, x_111); -lean_inc(x_119); -x_120 = lean_array_uset(x_116, x_6, x_119); -x_121 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_121, 0, x_114); -lean_ctor_set(x_121, 1, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_119); -lean_ctor_set(x_122, 1, x_121); -return x_122; +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set(x_112, 1, x_111); +return x_112; } } case 8: { -lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint64_t 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; uint8_t x_135; -x_123 = lean_ctor_get(x_3, 0); +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint64_t 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; uint8_t x_125; +x_113 = lean_ctor_get(x_3, 0); +lean_inc(x_113); +x_114 = lean_ctor_get(x_3, 1); +lean_inc(x_114); +x_115 = lean_ctor_get(x_3, 2); +lean_inc(x_115); +x_116 = lean_ctor_get(x_3, 3); +lean_inc(x_116); +x_117 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); +lean_inc(x_114); +x_118 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_114, x_4); +x_119 = lean_ctor_get(x_118, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_118, 1); +lean_inc(x_120); +lean_dec(x_118); +lean_inc(x_115); +x_121 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_115, x_120); +x_122 = lean_ctor_get(x_121, 0); +lean_inc(x_122); +x_123 = lean_ctor_get(x_121, 1); lean_inc(x_123); -x_124 = lean_ctor_get(x_3, 1); -lean_inc(x_124); -x_125 = lean_ctor_get(x_3, 2); -lean_inc(x_125); -x_126 = lean_ctor_get(x_3, 3); -lean_inc(x_126); -x_127 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); -lean_inc(x_124); -x_128 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_124, x_4); -x_129 = lean_ctor_get(x_128, 0); +lean_dec(x_121); +lean_inc(x_116); +x_124 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_116, x_123); +x_125 = !lean_is_exclusive(x_124); +if (x_125 == 0) +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; +x_126 = lean_ctor_get(x_124, 0); +x_127 = lean_ctor_get(x_124, 1); +x_128 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_128, 0, x_113); +lean_ctor_set(x_128, 1, x_114); +lean_ctor_set(x_128, 2, x_115); +lean_ctor_set(x_128, 3, x_116); +lean_ctor_set_uint64(x_128, sizeof(void*)*4, x_117); +x_129 = lean_expr_update_let(x_128, x_119, x_122, x_126); +x_130 = !lean_is_exclusive(x_127); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_131 = lean_ctor_get(x_127, 0); +x_132 = lean_ctor_get(x_127, 1); +x_133 = lean_array_uset(x_131, x_6, x_3); lean_inc(x_129); -x_130 = lean_ctor_get(x_128, 1); -lean_inc(x_130); -lean_dec(x_128); -lean_inc(x_125); -x_131 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_125, x_130); -x_132 = lean_ctor_get(x_131, 0); -lean_inc(x_132); -x_133 = lean_ctor_get(x_131, 1); -lean_inc(x_133); -lean_dec(x_131); -lean_inc(x_126); -x_134 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_126, x_133); -x_135 = !lean_is_exclusive(x_134); -if (x_135 == 0) +x_134 = lean_array_uset(x_132, x_6, x_129); +lean_ctor_set(x_127, 1, x_134); +lean_ctor_set(x_127, 0, x_133); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +else { -lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; uint8_t x_140; -x_136 = lean_ctor_get(x_134, 0); -x_137 = lean_ctor_get(x_134, 1); -x_138 = lean_ctor_get(x_137, 0); -lean_inc(x_138); -lean_inc(x_3); -x_139 = lean_array_uset(x_138, x_6, x_3); -x_140 = !lean_is_exclusive(x_3); -if (x_140 == 0) +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_135 = lean_ctor_get(x_127, 0); +x_136 = lean_ctor_get(x_127, 1); +lean_inc(x_136); +lean_inc(x_135); +lean_dec(x_127); +x_137 = lean_array_uset(x_135, x_6, x_3); +lean_inc(x_129); +x_138 = lean_array_uset(x_136, x_6, x_129); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set(x_139, 1, x_138); +lean_ctor_set(x_124, 1, x_139); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +} +else { -lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; -x_141 = lean_ctor_get(x_3, 3); -lean_dec(x_141); -x_142 = lean_ctor_get(x_3, 2); -lean_dec(x_142); -x_143 = lean_ctor_get(x_3, 1); -lean_dec(x_143); -x_144 = lean_ctor_get(x_3, 0); -lean_dec(x_144); -x_145 = lean_ctor_get(x_137, 1); +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_140 = lean_ctor_get(x_124, 0); +x_141 = lean_ctor_get(x_124, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_124); +x_142 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_142, 0, x_113); +lean_ctor_set(x_142, 1, x_114); +lean_ctor_set(x_142, 2, x_115); +lean_ctor_set(x_142, 3, x_116); +lean_ctor_set_uint64(x_142, sizeof(void*)*4, x_117); +x_143 = lean_expr_update_let(x_142, x_119, x_122, x_140); +x_144 = lean_ctor_get(x_141, 0); +lean_inc(x_144); +x_145 = lean_ctor_get(x_141, 1); lean_inc(x_145); -lean_dec(x_137); -x_146 = lean_expr_update_let(x_3, x_129, x_132, x_136); -lean_inc(x_146); -x_147 = lean_array_uset(x_145, x_6, x_146); -x_148 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_148, 0, x_139); -lean_ctor_set(x_148, 1, x_147); -lean_ctor_set(x_134, 1, x_148); -lean_ctor_set(x_134, 0, x_146); -return x_134; -} -else -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; -lean_dec(x_3); -x_149 = lean_ctor_get(x_137, 1); -lean_inc(x_149); -lean_dec(x_137); -x_150 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_150, 0, x_123); -lean_ctor_set(x_150, 1, x_124); -lean_ctor_set(x_150, 2, x_125); -lean_ctor_set(x_150, 3, x_126); -lean_ctor_set_uint64(x_150, sizeof(void*)*4, x_127); -x_151 = lean_expr_update_let(x_150, x_129, x_132, x_136); -lean_inc(x_151); -x_152 = lean_array_uset(x_149, x_6, x_151); -x_153 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_153, 0, x_139); -lean_ctor_set(x_153, 1, x_152); -lean_ctor_set(x_134, 1, x_153); -lean_ctor_set(x_134, 0, x_151); -return x_134; -} -} -else -{ -lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; -x_154 = lean_ctor_get(x_134, 0); -x_155 = lean_ctor_get(x_134, 1); -lean_inc(x_155); -lean_inc(x_154); -lean_dec(x_134); -x_156 = lean_ctor_get(x_155, 0); -lean_inc(x_156); -lean_inc(x_3); -x_157 = lean_array_uset(x_156, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - x_158 = x_3; +if (lean_is_exclusive(x_141)) { + lean_ctor_release(x_141, 0); + lean_ctor_release(x_141, 1); + x_146 = x_141; } else { - lean_dec_ref(x_3); - x_158 = lean_box(0); + lean_dec_ref(x_141); + x_146 = lean_box(0); } -x_159 = lean_ctor_get(x_155, 1); -lean_inc(x_159); -lean_dec(x_155); -if (lean_is_scalar(x_158)) { - x_160 = lean_alloc_ctor(8, 4, 8); +x_147 = lean_array_uset(x_144, x_6, x_3); +lean_inc(x_143); +x_148 = lean_array_uset(x_145, x_6, x_143); +if (lean_is_scalar(x_146)) { + x_149 = lean_alloc_ctor(0, 2, 0); } else { - x_160 = x_158; + x_149 = x_146; } -lean_ctor_set(x_160, 0, x_123); -lean_ctor_set(x_160, 1, x_124); -lean_ctor_set(x_160, 2, x_125); -lean_ctor_set(x_160, 3, x_126); -lean_ctor_set_uint64(x_160, sizeof(void*)*4, x_127); -x_161 = lean_expr_update_let(x_160, x_129, x_132, x_154); -lean_inc(x_161); -x_162 = lean_array_uset(x_159, x_6, x_161); -x_163 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_163, 0, x_157); -lean_ctor_set(x_163, 1, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_161); -lean_ctor_set(x_164, 1, x_163); -return x_164; +lean_ctor_set(x_149, 0, x_147); +lean_ctor_set(x_149, 1, x_148); +x_150 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_150, 0, x_143); +lean_ctor_set(x_150, 1, x_149); +return x_150; } } case 10: { -lean_object* x_165; lean_object* x_166; uint64_t x_167; lean_object* x_168; uint8_t x_169; -x_165 = lean_ctor_get(x_3, 0); +lean_object* x_151; lean_object* x_152; uint64_t x_153; lean_object* x_154; uint8_t x_155; +x_151 = lean_ctor_get(x_3, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_3, 1); +lean_inc(x_152); +x_153 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); +lean_inc(x_152); +x_154 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_152, x_4); +x_155 = !lean_is_exclusive(x_154); +if (x_155 == 0) +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; uint8_t x_160; +x_156 = lean_ctor_get(x_154, 0); +x_157 = lean_ctor_get(x_154, 1); +x_158 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_158, 0, x_151); +lean_ctor_set(x_158, 1, x_152); +lean_ctor_set_uint64(x_158, sizeof(void*)*2, x_153); +x_159 = lean_expr_update_mdata(x_158, x_156); +x_160 = !lean_is_exclusive(x_157); +if (x_160 == 0) +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_157, 0); +x_162 = lean_ctor_get(x_157, 1); +x_163 = lean_array_uset(x_161, x_6, x_3); +lean_inc(x_159); +x_164 = lean_array_uset(x_162, x_6, x_159); +lean_ctor_set(x_157, 1, x_164); +lean_ctor_set(x_157, 0, x_163); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +else +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_165 = lean_ctor_get(x_157, 0); +x_166 = lean_ctor_get(x_157, 1); +lean_inc(x_166); lean_inc(x_165); -x_166 = lean_ctor_get(x_3, 1); -lean_inc(x_166); -x_167 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); -lean_inc(x_166); -x_168 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_166, x_4); -x_169 = !lean_is_exclusive(x_168); -if (x_169 == 0) +lean_dec(x_157); +x_167 = lean_array_uset(x_165, x_6, x_3); +lean_inc(x_159); +x_168 = lean_array_uset(x_166, x_6, x_159); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_167); +lean_ctor_set(x_169, 1, x_168); +lean_ctor_set(x_154, 1, x_169); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +} +else { -lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; -x_170 = lean_ctor_get(x_168, 0); -x_171 = lean_ctor_get(x_168, 1); -x_172 = lean_ctor_get(x_171, 0); -lean_inc(x_172); -lean_inc(x_3); -x_173 = lean_array_uset(x_172, x_6, x_3); -x_174 = !lean_is_exclusive(x_3); -if (x_174 == 0) -{ -lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; -x_175 = lean_ctor_get(x_3, 1); -lean_dec(x_175); -x_176 = lean_ctor_get(x_3, 0); -lean_dec(x_176); -x_177 = lean_ctor_get(x_171, 1); -lean_inc(x_177); -lean_dec(x_171); -x_178 = lean_expr_update_mdata(x_3, x_170); -lean_inc(x_178); -x_179 = lean_array_uset(x_177, x_6, x_178); +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_170 = lean_ctor_get(x_154, 0); +x_171 = lean_ctor_get(x_154, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_154); +x_172 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_172, 0, x_151); +lean_ctor_set(x_172, 1, x_152); +lean_ctor_set_uint64(x_172, sizeof(void*)*2, x_153); +x_173 = lean_expr_update_mdata(x_172, x_170); +x_174 = lean_ctor_get(x_171, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_171, 1); +lean_inc(x_175); +if (lean_is_exclusive(x_171)) { + lean_ctor_release(x_171, 0); + lean_ctor_release(x_171, 1); + x_176 = x_171; +} else { + lean_dec_ref(x_171); + x_176 = lean_box(0); +} +x_177 = lean_array_uset(x_174, x_6, x_3); +lean_inc(x_173); +x_178 = lean_array_uset(x_175, x_6, x_173); +if (lean_is_scalar(x_176)) { + x_179 = lean_alloc_ctor(0, 2, 0); +} else { + x_179 = x_176; +} +lean_ctor_set(x_179, 0, x_177); +lean_ctor_set(x_179, 1, x_178); x_180 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_180, 0, x_173); lean_ctor_set(x_180, 1, x_179); -lean_ctor_set(x_168, 1, x_180); -lean_ctor_set(x_168, 0, x_178); -return x_168; -} -else -{ -lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; -lean_dec(x_3); -x_181 = lean_ctor_get(x_171, 1); -lean_inc(x_181); -lean_dec(x_171); -x_182 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_182, 0, x_165); -lean_ctor_set(x_182, 1, x_166); -lean_ctor_set_uint64(x_182, sizeof(void*)*2, x_167); -x_183 = lean_expr_update_mdata(x_182, x_170); -lean_inc(x_183); -x_184 = lean_array_uset(x_181, x_6, x_183); -x_185 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_185, 0, x_173); -lean_ctor_set(x_185, 1, x_184); -lean_ctor_set(x_168, 1, x_185); -lean_ctor_set(x_168, 0, x_183); -return x_168; -} -} -else -{ -lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; -x_186 = lean_ctor_get(x_168, 0); -x_187 = lean_ctor_get(x_168, 1); -lean_inc(x_187); -lean_inc(x_186); -lean_dec(x_168); -x_188 = lean_ctor_get(x_187, 0); -lean_inc(x_188); -lean_inc(x_3); -x_189 = lean_array_uset(x_188, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_190 = x_3; -} else { - lean_dec_ref(x_3); - x_190 = lean_box(0); -} -x_191 = lean_ctor_get(x_187, 1); -lean_inc(x_191); -lean_dec(x_187); -if (lean_is_scalar(x_190)) { - x_192 = lean_alloc_ctor(10, 2, 8); -} else { - x_192 = x_190; -} -lean_ctor_set(x_192, 0, x_165); -lean_ctor_set(x_192, 1, x_166); -lean_ctor_set_uint64(x_192, sizeof(void*)*2, x_167); -x_193 = lean_expr_update_mdata(x_192, x_186); -lean_inc(x_193); -x_194 = lean_array_uset(x_191, x_6, x_193); -x_195 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_195, 0, x_189); -lean_ctor_set(x_195, 1, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_193); -lean_ctor_set(x_196, 1, x_195); -return x_196; +return x_180; } } case 11: { -lean_object* x_197; lean_object* x_198; lean_object* x_199; uint64_t x_200; lean_object* x_201; uint8_t x_202; -x_197 = lean_ctor_get(x_3, 0); +lean_object* x_181; lean_object* x_182; lean_object* x_183; uint64_t x_184; lean_object* x_185; uint8_t x_186; +x_181 = lean_ctor_get(x_3, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_3, 1); +lean_inc(x_182); +x_183 = lean_ctor_get(x_3, 2); +lean_inc(x_183); +x_184 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_183); +x_185 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_183, x_4); +x_186 = !lean_is_exclusive(x_185); +if (x_186 == 0) +{ +lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; +x_187 = lean_ctor_get(x_185, 0); +x_188 = lean_ctor_get(x_185, 1); +x_189 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_189, 0, x_181); +lean_ctor_set(x_189, 1, x_182); +lean_ctor_set(x_189, 2, x_183); +lean_ctor_set_uint64(x_189, sizeof(void*)*3, x_184); +x_190 = lean_expr_update_proj(x_189, x_187); +x_191 = !lean_is_exclusive(x_188); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; +x_192 = lean_ctor_get(x_188, 0); +x_193 = lean_ctor_get(x_188, 1); +x_194 = lean_array_uset(x_192, x_6, x_3); +lean_inc(x_190); +x_195 = lean_array_uset(x_193, x_6, x_190); +lean_ctor_set(x_188, 1, x_195); +lean_ctor_set(x_188, 0, x_194); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +else +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +x_196 = lean_ctor_get(x_188, 0); +x_197 = lean_ctor_get(x_188, 1); lean_inc(x_197); -x_198 = lean_ctor_get(x_3, 1); -lean_inc(x_198); -x_199 = lean_ctor_get(x_3, 2); -lean_inc(x_199); -x_200 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_199); -x_201 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_MVarRenaming_apply___spec__1(x_1, x_2, x_199, x_4); -x_202 = !lean_is_exclusive(x_201); -if (x_202 == 0) +lean_inc(x_196); +lean_dec(x_188); +x_198 = lean_array_uset(x_196, x_6, x_3); +lean_inc(x_190); +x_199 = lean_array_uset(x_197, x_6, x_190); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_198); +lean_ctor_set(x_200, 1, x_199); +lean_ctor_set(x_185, 1, x_200); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +} +else { -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_201, 0); -x_204 = lean_ctor_get(x_201, 1); -x_205 = lean_ctor_get(x_204, 0); +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; lean_object* x_211; +x_201 = lean_ctor_get(x_185, 0); +x_202 = lean_ctor_get(x_185, 1); +lean_inc(x_202); +lean_inc(x_201); +lean_dec(x_185); +x_203 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_203, 0, x_181); +lean_ctor_set(x_203, 1, x_182); +lean_ctor_set(x_203, 2, x_183); +lean_ctor_set_uint64(x_203, sizeof(void*)*3, x_184); +x_204 = lean_expr_update_proj(x_203, x_201); +x_205 = lean_ctor_get(x_202, 0); lean_inc(x_205); -lean_inc(x_3); -x_206 = lean_array_uset(x_205, x_6, x_3); -x_207 = !lean_is_exclusive(x_3); -if (x_207 == 0) -{ -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; -x_208 = lean_ctor_get(x_3, 2); -lean_dec(x_208); -x_209 = lean_ctor_get(x_3, 1); -lean_dec(x_209); -x_210 = lean_ctor_get(x_3, 0); -lean_dec(x_210); -x_211 = lean_ctor_get(x_204, 1); -lean_inc(x_211); -lean_dec(x_204); -x_212 = lean_expr_update_proj(x_3, x_203); -lean_inc(x_212); -x_213 = lean_array_uset(x_211, x_6, x_212); -x_214 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_214, 0, x_206); -lean_ctor_set(x_214, 1, x_213); -lean_ctor_set(x_201, 1, x_214); -lean_ctor_set(x_201, 0, x_212); -return x_201; -} -else -{ -lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; -lean_dec(x_3); -x_215 = lean_ctor_get(x_204, 1); -lean_inc(x_215); -lean_dec(x_204); -x_216 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_216, 0, x_197); -lean_ctor_set(x_216, 1, x_198); -lean_ctor_set(x_216, 2, x_199); -lean_ctor_set_uint64(x_216, sizeof(void*)*3, x_200); -x_217 = lean_expr_update_proj(x_216, x_203); -lean_inc(x_217); -x_218 = lean_array_uset(x_215, x_6, x_217); -x_219 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_219, 0, x_206); -lean_ctor_set(x_219, 1, x_218); -lean_ctor_set(x_201, 1, x_219); -lean_ctor_set(x_201, 0, x_217); -return x_201; -} -} -else -{ -lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; -x_220 = lean_ctor_get(x_201, 0); -x_221 = lean_ctor_get(x_201, 1); -lean_inc(x_221); -lean_inc(x_220); -lean_dec(x_201); -x_222 = lean_ctor_get(x_221, 0); -lean_inc(x_222); -lean_inc(x_3); -x_223 = lean_array_uset(x_222, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_224 = x_3; +x_206 = lean_ctor_get(x_202, 1); +lean_inc(x_206); +if (lean_is_exclusive(x_202)) { + lean_ctor_release(x_202, 0); + lean_ctor_release(x_202, 1); + x_207 = x_202; } else { - lean_dec_ref(x_3); - x_224 = lean_box(0); + lean_dec_ref(x_202); + x_207 = lean_box(0); } -x_225 = lean_ctor_get(x_221, 1); -lean_inc(x_225); -lean_dec(x_221); -if (lean_is_scalar(x_224)) { - x_226 = lean_alloc_ctor(11, 3, 8); +x_208 = lean_array_uset(x_205, x_6, x_3); +lean_inc(x_204); +x_209 = lean_array_uset(x_206, x_6, x_204); +if (lean_is_scalar(x_207)) { + x_210 = lean_alloc_ctor(0, 2, 0); } else { - x_226 = x_224; + x_210 = x_207; } -lean_ctor_set(x_226, 0, x_197); -lean_ctor_set(x_226, 1, x_198); -lean_ctor_set(x_226, 2, x_199); -lean_ctor_set_uint64(x_226, sizeof(void*)*3, x_200); -x_227 = lean_expr_update_proj(x_226, x_220); -lean_inc(x_227); -x_228 = lean_array_uset(x_225, x_6, x_227); -x_229 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_229, 0, x_223); -lean_ctor_set(x_229, 1, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_227); -lean_ctor_set(x_230, 1, x_229); -return x_230; +lean_ctor_set(x_210, 0, x_208); +lean_ctor_set(x_210, 1, x_209); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_204); +lean_ctor_set(x_211, 1, x_210); +return x_211; } } default: { -lean_object* x_231; -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_3); -lean_ctor_set(x_231, 1, x_4); -return x_231; +lean_object* x_212; +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_3); +lean_ctor_set(x_212, 1, x_4); +return x_212; } } } -block_240: +block_227: { -lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; -x_235 = lean_array_uset(x_233, x_6, x_3); -x_236 = lean_ctor_get(x_4, 1); -lean_inc(x_236); +uint8_t x_215; +x_215 = !lean_is_exclusive(x_4); +if (x_215 == 0) +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get(x_4, 1); +x_218 = lean_array_uset(x_216, x_6, x_3); +lean_inc(x_214); +x_219 = lean_array_uset(x_217, x_6, x_214); +lean_ctor_set(x_4, 1, x_219); +lean_ctor_set(x_4, 0, x_218); +x_220 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_220, 0, x_214); +lean_ctor_set(x_220, 1, x_4); +return x_220; +} +else +{ +lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_221 = lean_ctor_get(x_4, 0); +x_222 = lean_ctor_get(x_4, 1); +lean_inc(x_222); +lean_inc(x_221); lean_dec(x_4); -lean_inc(x_234); -x_237 = lean_array_uset(x_236, x_6, x_234); -x_238 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_238, 0, x_235); -lean_ctor_set(x_238, 1, x_237); -x_239 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_239, 0, x_234); -lean_ctor_set(x_239, 1, x_238); -return x_239; +x_223 = lean_array_uset(x_221, x_6, x_3); +lean_inc(x_214); +x_224 = lean_array_uset(x_222, x_6, x_214); +x_225 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_225, 0, x_223); +lean_ctor_set(x_225, 1, x_224); +x_226 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_226, 0, x_214); +lean_ctor_set(x_226, 1, x_225); +return x_226; +} } } } diff --git a/stage0/stdlib/Lean/Meta/Tactic/FVarSubst.c b/stage0/stdlib/Lean/Meta/Tactic/FVarSubst.c index 9c6fce9863..28d69d0690 100644 --- a/stage0/stdlib/Lean/Meta/Tactic/FVarSubst.c +++ b/stage0/stdlib/Lean/Meta/Tactic/FVarSubst.c @@ -471,64 +471,63 @@ return x_2; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_233; lean_object* x_234; lean_object* x_241; size_t x_242; uint8_t x_243; +size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_214; lean_object* x_228; lean_object* x_229; size_t x_230; uint8_t x_231; x_5 = lean_ptr_addr(x_3); x_6 = x_2 == 0 ? x_5 : x_5 % x_2; -x_233 = lean_ctor_get(x_4, 0); -lean_inc(x_233); -x_241 = lean_array_uget(x_233, x_6); -x_242 = lean_ptr_addr(x_241); -lean_dec(x_241); -x_243 = x_242 == x_5; -if (x_243 == 0) +x_228 = lean_ctor_get(x_4, 0); +lean_inc(x_228); +x_229 = lean_array_uget(x_228, x_6); +lean_dec(x_228); +x_230 = lean_ptr_addr(x_229); +lean_dec(x_229); +x_231 = x_230 == x_5; +if (x_231 == 0) { if (lean_obj_tag(x_3) == 1) { -lean_object* x_244; lean_object* x_245; -x_244 = lean_ctor_get(x_3, 0); -lean_inc(x_244); -x_245 = l_Std_AssocList_find_x3f___at_Lean_Meta_FVarSubst_find_x3f___spec__1(x_244, x_1); -lean_dec(x_244); -if (lean_obj_tag(x_245) == 0) +lean_object* x_232; lean_object* x_233; +x_232 = lean_ctor_get(x_3, 0); +lean_inc(x_232); +x_233 = l_Std_AssocList_find_x3f___at_Lean_Meta_FVarSubst_find_x3f___spec__1(x_232, x_1); +lean_dec(x_232); +if (lean_obj_tag(x_233) == 0) { lean_inc(x_3); -x_234 = x_3; -goto block_240; +x_214 = x_3; +goto block_227; } else { -lean_object* x_246; -x_246 = lean_ctor_get(x_245, 0); -lean_inc(x_246); -lean_dec(x_245); -x_234 = x_246; -goto block_240; -} -} -else -{ -lean_object* x_247; +lean_object* x_234; +x_234 = lean_ctor_get(x_233, 0); +lean_inc(x_234); lean_dec(x_233); -x_247 = lean_box(0); -x_7 = x_247; -goto block_232; +x_214 = x_234; +goto block_227; } } else { -lean_object* x_248; lean_object* x_249; lean_object* x_250; -lean_dec(x_233); +lean_object* x_235; +x_235 = lean_box(0); +x_7 = x_235; +goto block_213; +} +} +else +{ +lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_dec(x_3); -x_248 = lean_ctor_get(x_4, 1); -lean_inc(x_248); -x_249 = lean_array_uget(x_248, x_6); -lean_dec(x_248); -x_250 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_250, 0, x_249); -lean_ctor_set(x_250, 1, x_4); -return x_250; +x_236 = lean_ctor_get(x_4, 1); +lean_inc(x_236); +x_237 = lean_array_uget(x_236, x_6); +lean_dec(x_236); +x_238 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_238, 0, x_237); +lean_ctor_set(x_238, 1, x_4); +return x_238; } -block_232: +block_213: { lean_dec(x_7); switch (lean_obj_tag(x_3)) { @@ -555,721 +554,660 @@ 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_14, 0); x_17 = lean_ctor_get(x_14, 1); -x_18 = lean_ctor_get(x_17, 0); -lean_inc(x_18); -lean_inc(x_3); -x_19 = lean_array_uset(x_18, x_6, x_3); -x_20 = !lean_is_exclusive(x_3); +x_18 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_18, 0, x_8); +lean_ctor_set(x_18, 1, x_9); +lean_ctor_set_uint64(x_18, sizeof(void*)*2, x_10); +x_19 = lean_expr_update_app(x_18, x_12, x_16); +x_20 = !lean_is_exclusive(x_17); if (x_20 == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -x_21 = lean_ctor_get(x_3, 1); -lean_dec(x_21); -x_22 = lean_ctor_get(x_3, 0); -lean_dec(x_22); -x_23 = lean_ctor_get(x_17, 1); -lean_inc(x_23); -lean_dec(x_17); -x_24 = lean_expr_update_app(x_3, x_12, x_16); -lean_inc(x_24); -x_25 = lean_array_uset(x_23, x_6, x_24); -x_26 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_26, 0, x_19); -lean_ctor_set(x_26, 1, x_25); -lean_ctor_set(x_14, 1, x_26); -lean_ctor_set(x_14, 0, x_24); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_17, 0); +x_22 = lean_ctor_get(x_17, 1); +x_23 = lean_array_uset(x_21, x_6, x_3); +lean_inc(x_19); +x_24 = lean_array_uset(x_22, x_6, x_19); +lean_ctor_set(x_17, 1, x_24); +lean_ctor_set(x_17, 0, x_23); +lean_ctor_set(x_14, 0, x_19); return x_14; } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_3); -x_27 = lean_ctor_get(x_17, 1); -lean_inc(x_27); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_17, 0); +x_26 = lean_ctor_get(x_17, 1); +lean_inc(x_26); +lean_inc(x_25); lean_dec(x_17); -x_28 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_28, 0, x_8); -lean_ctor_set(x_28, 1, x_9); -lean_ctor_set_uint64(x_28, sizeof(void*)*2, x_10); -x_29 = lean_expr_update_app(x_28, x_12, x_16); -lean_inc(x_29); -x_30 = lean_array_uset(x_27, x_6, x_29); -x_31 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_31, 0, x_19); -lean_ctor_set(x_31, 1, x_30); -lean_ctor_set(x_14, 1, x_31); -lean_ctor_set(x_14, 0, x_29); +x_27 = lean_array_uset(x_25, x_6, x_3); +lean_inc(x_19); +x_28 = lean_array_uset(x_26, x_6, x_19); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_14, 1, x_29); +lean_ctor_set(x_14, 0, x_19); return x_14; } } 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_14, 0); -x_33 = lean_ctor_get(x_14, 1); -lean_inc(x_33); -lean_inc(x_32); +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_30 = lean_ctor_get(x_14, 0); +x_31 = lean_ctor_get(x_14, 1); +lean_inc(x_31); +lean_inc(x_30); lean_dec(x_14); -x_34 = lean_ctor_get(x_33, 0); +x_32 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_32, 0, x_8); +lean_ctor_set(x_32, 1, x_9); +lean_ctor_set_uint64(x_32, sizeof(void*)*2, x_10); +x_33 = lean_expr_update_app(x_32, x_12, x_30); +x_34 = lean_ctor_get(x_31, 0); lean_inc(x_34); -lean_inc(x_3); -x_35 = lean_array_uset(x_34, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_36 = x_3; +x_35 = lean_ctor_get(x_31, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_36 = x_31; } else { - lean_dec_ref(x_3); + lean_dec_ref(x_31); x_36 = lean_box(0); } -x_37 = lean_ctor_get(x_33, 1); -lean_inc(x_37); -lean_dec(x_33); +x_37 = lean_array_uset(x_34, x_6, x_3); +lean_inc(x_33); +x_38 = lean_array_uset(x_35, x_6, x_33); if (lean_is_scalar(x_36)) { - x_38 = lean_alloc_ctor(5, 2, 8); + x_39 = lean_alloc_ctor(0, 2, 0); } else { - x_38 = x_36; + x_39 = x_36; } -lean_ctor_set(x_38, 0, x_8); -lean_ctor_set(x_38, 1, x_9); -lean_ctor_set_uint64(x_38, sizeof(void*)*2, x_10); -x_39 = lean_expr_update_app(x_38, x_12, x_32); -lean_inc(x_39); -x_40 = lean_array_uset(x_37, x_6, x_39); -x_41 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_41, 0, x_35); -lean_ctor_set(x_41, 1, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_39); -lean_ctor_set(x_42, 1, x_41); -return x_42; +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_33); +lean_ctor_set(x_40, 1, x_39); +return x_40; } } case 6: { -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_object* x_49; lean_object* x_50; uint8_t x_51; -x_43 = lean_ctor_get(x_3, 0); +lean_object* x_41; lean_object* x_42; lean_object* x_43; uint64_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_41 = lean_ctor_get(x_3, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_3, 1); +lean_inc(x_42); +x_43 = lean_ctor_get(x_3, 2); lean_inc(x_43); -x_44 = lean_ctor_get(x_3, 1); -lean_inc(x_44); -x_45 = lean_ctor_get(x_3, 2); -lean_inc(x_45); -x_46 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_44); -x_47 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_44, x_4); -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); -lean_inc(x_49); -lean_dec(x_47); -lean_inc(x_45); -x_50 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_45, x_49); -x_51 = !lean_is_exclusive(x_50); -if (x_51 == 0) +x_44 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_42); +x_45 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_42, x_4); +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +lean_inc(x_43); +x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_43, x_47); +x_49 = !lean_is_exclusive(x_48); +if (x_49 == 0) { -lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; -x_52 = lean_ctor_get(x_50, 0); -x_53 = lean_ctor_get(x_50, 1); -x_54 = lean_ctor_get(x_53, 0); +lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; +x_50 = lean_ctor_get(x_48, 0); +x_51 = lean_ctor_get(x_48, 1); +x_52 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_52, 0, x_41); +lean_ctor_set(x_52, 1, x_42); +lean_ctor_set(x_52, 2, x_43); +lean_ctor_set_uint64(x_52, sizeof(void*)*3, x_44); +x_53 = (uint8_t)((x_44 << 24) >> 61); +x_54 = lean_expr_update_lambda(x_52, x_53, x_46, x_50); +x_55 = !lean_is_exclusive(x_51); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_51, 0); +x_57 = lean_ctor_get(x_51, 1); +x_58 = lean_array_uset(x_56, x_6, x_3); lean_inc(x_54); -lean_inc(x_3); -x_55 = lean_array_uset(x_54, x_6, x_3); -x_56 = !lean_is_exclusive(x_3); -if (x_56 == 0) +x_59 = lean_array_uset(x_57, x_6, x_54); +lean_ctor_set(x_51, 1, x_59); +lean_ctor_set(x_51, 0, x_58); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} +else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; -x_57 = lean_ctor_get(x_3, 2); -lean_dec(x_57); -x_58 = lean_ctor_get(x_3, 1); -lean_dec(x_58); -x_59 = lean_ctor_get(x_3, 0); -lean_dec(x_59); -x_60 = lean_ctor_get(x_53, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_60 = lean_ctor_get(x_51, 0); +x_61 = lean_ctor_get(x_51, 1); +lean_inc(x_61); lean_inc(x_60); -lean_dec(x_53); -x_61 = (uint8_t)((x_46 << 24) >> 61); -x_62 = lean_expr_update_lambda(x_3, x_61, x_48, x_52); -lean_inc(x_62); -x_63 = lean_array_uset(x_60, x_6, x_62); +lean_dec(x_51); +x_62 = lean_array_uset(x_60, x_6, x_3); +lean_inc(x_54); +x_63 = lean_array_uset(x_61, x_6, x_54); x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_55); +lean_ctor_set(x_64, 0, x_62); lean_ctor_set(x_64, 1, x_63); -lean_ctor_set(x_50, 1, x_64); -lean_ctor_set(x_50, 0, x_62); -return x_50; +lean_ctor_set(x_48, 1, x_64); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} } else { -lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; -lean_dec(x_3); -x_65 = lean_ctor_get(x_53, 1); +lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_65 = lean_ctor_get(x_48, 0); +x_66 = lean_ctor_get(x_48, 1); +lean_inc(x_66); lean_inc(x_65); -lean_dec(x_53); -x_66 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_66, 0, x_43); -lean_ctor_set(x_66, 1, x_44); -lean_ctor_set(x_66, 2, x_45); -lean_ctor_set_uint64(x_66, sizeof(void*)*3, x_46); -x_67 = (uint8_t)((x_46 << 24) >> 61); -x_68 = lean_expr_update_lambda(x_66, x_67, x_48, x_52); -lean_inc(x_68); -x_69 = lean_array_uset(x_65, x_6, x_68); -x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_55); -lean_ctor_set(x_70, 1, x_69); -lean_ctor_set(x_50, 1, x_70); -lean_ctor_set(x_50, 0, x_68); -return x_50; -} -} -else -{ -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_71 = lean_ctor_get(x_50, 0); -x_72 = lean_ctor_get(x_50, 1); -lean_inc(x_72); +lean_dec(x_48); +x_67 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_67, 0, x_41); +lean_ctor_set(x_67, 1, x_42); +lean_ctor_set(x_67, 2, x_43); +lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_44); +x_68 = (uint8_t)((x_44 << 24) >> 61); +x_69 = lean_expr_update_lambda(x_67, x_68, x_46, x_65); +x_70 = lean_ctor_get(x_66, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_66, 1); lean_inc(x_71); -lean_dec(x_50); -x_73 = lean_ctor_get(x_72, 0); -lean_inc(x_73); -lean_inc(x_3); -x_74 = lean_array_uset(x_73, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_75 = x_3; +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + lean_ctor_release(x_66, 1); + x_72 = x_66; } else { - lean_dec_ref(x_3); - x_75 = lean_box(0); + lean_dec_ref(x_66); + x_72 = lean_box(0); } -x_76 = lean_ctor_get(x_72, 1); -lean_inc(x_76); -lean_dec(x_72); -if (lean_is_scalar(x_75)) { - x_77 = lean_alloc_ctor(6, 3, 8); +x_73 = lean_array_uset(x_70, x_6, x_3); +lean_inc(x_69); +x_74 = lean_array_uset(x_71, x_6, x_69); +if (lean_is_scalar(x_72)) { + x_75 = lean_alloc_ctor(0, 2, 0); } else { - x_77 = x_75; + x_75 = x_72; } -lean_ctor_set(x_77, 0, x_43); -lean_ctor_set(x_77, 1, x_44); -lean_ctor_set(x_77, 2, x_45); -lean_ctor_set_uint64(x_77, sizeof(void*)*3, x_46); -x_78 = (uint8_t)((x_46 << 24) >> 61); -x_79 = lean_expr_update_lambda(x_77, x_78, x_48, x_71); -lean_inc(x_79); -x_80 = lean_array_uset(x_76, x_6, x_79); -x_81 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_81, 0, x_74); -lean_ctor_set(x_81, 1, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_79); -lean_ctor_set(x_82, 1, x_81); -return x_82; +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set(x_75, 1, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_69); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } case 7: { -lean_object* x_83; lean_object* x_84; lean_object* x_85; uint64_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; -x_83 = lean_ctor_get(x_3, 0); +lean_object* x_77; lean_object* x_78; lean_object* x_79; uint64_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; +x_77 = lean_ctor_get(x_3, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_3, 1); +lean_inc(x_78); +x_79 = lean_ctor_get(x_3, 2); +lean_inc(x_79); +x_80 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_78); +x_81 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_78, x_4); +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); lean_inc(x_83); -x_84 = lean_ctor_get(x_3, 1); -lean_inc(x_84); -x_85 = lean_ctor_get(x_3, 2); -lean_inc(x_85); -x_86 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_84); -x_87 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_84, x_4); -x_88 = lean_ctor_get(x_87, 0); -lean_inc(x_88); -x_89 = lean_ctor_get(x_87, 1); -lean_inc(x_89); -lean_dec(x_87); -lean_inc(x_85); -x_90 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_85, x_89); -x_91 = !lean_is_exclusive(x_90); +lean_dec(x_81); +lean_inc(x_79); +x_84 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_79, x_83); +x_85 = !lean_is_exclusive(x_84); +if (x_85 == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; uint8_t x_89; lean_object* x_90; uint8_t x_91; +x_86 = lean_ctor_get(x_84, 0); +x_87 = lean_ctor_get(x_84, 1); +x_88 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_88, 0, x_77); +lean_ctor_set(x_88, 1, x_78); +lean_ctor_set(x_88, 2, x_79); +lean_ctor_set_uint64(x_88, sizeof(void*)*3, x_80); +x_89 = (uint8_t)((x_80 << 24) >> 61); +x_90 = lean_expr_update_forall(x_88, x_89, x_82, x_86); +x_91 = !lean_is_exclusive(x_87); if (x_91 == 0) { -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; uint8_t x_96; -x_92 = lean_ctor_get(x_90, 0); -x_93 = lean_ctor_get(x_90, 1); -x_94 = lean_ctor_get(x_93, 0); -lean_inc(x_94); -lean_inc(x_3); -x_95 = lean_array_uset(x_94, x_6, x_3); -x_96 = !lean_is_exclusive(x_3); -if (x_96 == 0) +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_92 = lean_ctor_get(x_87, 0); +x_93 = lean_ctor_get(x_87, 1); +x_94 = lean_array_uset(x_92, x_6, x_3); +lean_inc(x_90); +x_95 = lean_array_uset(x_93, x_6, x_90); +lean_ctor_set(x_87, 1, x_95); +lean_ctor_set(x_87, 0, x_94); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_97 = lean_ctor_get(x_3, 2); -lean_dec(x_97); -x_98 = lean_ctor_get(x_3, 1); -lean_dec(x_98); -x_99 = lean_ctor_get(x_3, 0); -lean_dec(x_99); -x_100 = lean_ctor_get(x_93, 1); -lean_inc(x_100); -lean_dec(x_93); -x_101 = (uint8_t)((x_86 << 24) >> 61); -x_102 = lean_expr_update_forall(x_3, x_101, x_88, x_92); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_96 = lean_ctor_get(x_87, 0); +x_97 = lean_ctor_get(x_87, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_87); +x_98 = lean_array_uset(x_96, x_6, x_3); +lean_inc(x_90); +x_99 = lean_array_uset(x_97, x_6, x_90); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +lean_ctor_set(x_84, 1, x_100); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_101 = lean_ctor_get(x_84, 0); +x_102 = lean_ctor_get(x_84, 1); lean_inc(x_102); -x_103 = lean_array_uset(x_100, x_6, x_102); -x_104 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_104, 0, x_95); -lean_ctor_set(x_104, 1, x_103); -lean_ctor_set(x_90, 1, x_104); -lean_ctor_set(x_90, 0, x_102); -return x_90; +lean_inc(x_101); +lean_dec(x_84); +x_103 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_103, 0, x_77); +lean_ctor_set(x_103, 1, x_78); +lean_ctor_set(x_103, 2, x_79); +lean_ctor_set_uint64(x_103, sizeof(void*)*3, x_80); +x_104 = (uint8_t)((x_80 << 24) >> 61); +x_105 = lean_expr_update_forall(x_103, x_104, x_82, x_101); +x_106 = lean_ctor_get(x_102, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_102, 1); +lean_inc(x_107); +if (lean_is_exclusive(x_102)) { + lean_ctor_release(x_102, 0); + lean_ctor_release(x_102, 1); + x_108 = x_102; +} else { + lean_dec_ref(x_102); + x_108 = lean_box(0); } -else -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_3); -x_105 = lean_ctor_get(x_93, 1); +x_109 = lean_array_uset(x_106, x_6, x_3); lean_inc(x_105); -lean_dec(x_93); -x_106 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_106, 0, x_83); -lean_ctor_set(x_106, 1, x_84); -lean_ctor_set(x_106, 2, x_85); -lean_ctor_set_uint64(x_106, sizeof(void*)*3, x_86); -x_107 = (uint8_t)((x_86 << 24) >> 61); -x_108 = lean_expr_update_forall(x_106, x_107, x_88, x_92); -lean_inc(x_108); -x_109 = lean_array_uset(x_105, x_6, x_108); -x_110 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_110, 0, x_95); -lean_ctor_set(x_110, 1, x_109); -lean_ctor_set(x_90, 1, x_110); -lean_ctor_set(x_90, 0, x_108); -return x_90; -} -} -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; uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; -x_111 = lean_ctor_get(x_90, 0); -x_112 = lean_ctor_get(x_90, 1); -lean_inc(x_112); -lean_inc(x_111); -lean_dec(x_90); -x_113 = lean_ctor_get(x_112, 0); -lean_inc(x_113); -lean_inc(x_3); -x_114 = lean_array_uset(x_113, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_115 = x_3; +x_110 = lean_array_uset(x_107, x_6, x_105); +if (lean_is_scalar(x_108)) { + x_111 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_3); - x_115 = lean_box(0); + x_111 = x_108; } -x_116 = lean_ctor_get(x_112, 1); -lean_inc(x_116); -lean_dec(x_112); -if (lean_is_scalar(x_115)) { - x_117 = lean_alloc_ctor(7, 3, 8); -} else { - x_117 = x_115; -} -lean_ctor_set(x_117, 0, x_83); -lean_ctor_set(x_117, 1, x_84); -lean_ctor_set(x_117, 2, x_85); -lean_ctor_set_uint64(x_117, sizeof(void*)*3, x_86); -x_118 = (uint8_t)((x_86 << 24) >> 61); -x_119 = lean_expr_update_forall(x_117, x_118, x_88, x_111); -lean_inc(x_119); -x_120 = lean_array_uset(x_116, x_6, x_119); -x_121 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_121, 0, x_114); -lean_ctor_set(x_121, 1, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_119); -lean_ctor_set(x_122, 1, x_121); -return x_122; +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set(x_112, 1, x_111); +return x_112; } } case 8: { -lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint64_t 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; uint8_t x_135; -x_123 = lean_ctor_get(x_3, 0); +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint64_t 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; uint8_t x_125; +x_113 = lean_ctor_get(x_3, 0); +lean_inc(x_113); +x_114 = lean_ctor_get(x_3, 1); +lean_inc(x_114); +x_115 = lean_ctor_get(x_3, 2); +lean_inc(x_115); +x_116 = lean_ctor_get(x_3, 3); +lean_inc(x_116); +x_117 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); +lean_inc(x_114); +x_118 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_114, x_4); +x_119 = lean_ctor_get(x_118, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_118, 1); +lean_inc(x_120); +lean_dec(x_118); +lean_inc(x_115); +x_121 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_115, x_120); +x_122 = lean_ctor_get(x_121, 0); +lean_inc(x_122); +x_123 = lean_ctor_get(x_121, 1); lean_inc(x_123); -x_124 = lean_ctor_get(x_3, 1); -lean_inc(x_124); -x_125 = lean_ctor_get(x_3, 2); -lean_inc(x_125); -x_126 = lean_ctor_get(x_3, 3); -lean_inc(x_126); -x_127 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); -lean_inc(x_124); -x_128 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_124, x_4); -x_129 = lean_ctor_get(x_128, 0); +lean_dec(x_121); +lean_inc(x_116); +x_124 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_116, x_123); +x_125 = !lean_is_exclusive(x_124); +if (x_125 == 0) +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; +x_126 = lean_ctor_get(x_124, 0); +x_127 = lean_ctor_get(x_124, 1); +x_128 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_128, 0, x_113); +lean_ctor_set(x_128, 1, x_114); +lean_ctor_set(x_128, 2, x_115); +lean_ctor_set(x_128, 3, x_116); +lean_ctor_set_uint64(x_128, sizeof(void*)*4, x_117); +x_129 = lean_expr_update_let(x_128, x_119, x_122, x_126); +x_130 = !lean_is_exclusive(x_127); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_131 = lean_ctor_get(x_127, 0); +x_132 = lean_ctor_get(x_127, 1); +x_133 = lean_array_uset(x_131, x_6, x_3); lean_inc(x_129); -x_130 = lean_ctor_get(x_128, 1); -lean_inc(x_130); -lean_dec(x_128); -lean_inc(x_125); -x_131 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_125, x_130); -x_132 = lean_ctor_get(x_131, 0); -lean_inc(x_132); -x_133 = lean_ctor_get(x_131, 1); -lean_inc(x_133); -lean_dec(x_131); -lean_inc(x_126); -x_134 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_126, x_133); -x_135 = !lean_is_exclusive(x_134); -if (x_135 == 0) +x_134 = lean_array_uset(x_132, x_6, x_129); +lean_ctor_set(x_127, 1, x_134); +lean_ctor_set(x_127, 0, x_133); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +else { -lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; uint8_t x_140; -x_136 = lean_ctor_get(x_134, 0); -x_137 = lean_ctor_get(x_134, 1); -x_138 = lean_ctor_get(x_137, 0); -lean_inc(x_138); -lean_inc(x_3); -x_139 = lean_array_uset(x_138, x_6, x_3); -x_140 = !lean_is_exclusive(x_3); -if (x_140 == 0) +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_135 = lean_ctor_get(x_127, 0); +x_136 = lean_ctor_get(x_127, 1); +lean_inc(x_136); +lean_inc(x_135); +lean_dec(x_127); +x_137 = lean_array_uset(x_135, x_6, x_3); +lean_inc(x_129); +x_138 = lean_array_uset(x_136, x_6, x_129); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set(x_139, 1, x_138); +lean_ctor_set(x_124, 1, x_139); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +} +else { -lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; -x_141 = lean_ctor_get(x_3, 3); -lean_dec(x_141); -x_142 = lean_ctor_get(x_3, 2); -lean_dec(x_142); -x_143 = lean_ctor_get(x_3, 1); -lean_dec(x_143); -x_144 = lean_ctor_get(x_3, 0); -lean_dec(x_144); -x_145 = lean_ctor_get(x_137, 1); +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_140 = lean_ctor_get(x_124, 0); +x_141 = lean_ctor_get(x_124, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_124); +x_142 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_142, 0, x_113); +lean_ctor_set(x_142, 1, x_114); +lean_ctor_set(x_142, 2, x_115); +lean_ctor_set(x_142, 3, x_116); +lean_ctor_set_uint64(x_142, sizeof(void*)*4, x_117); +x_143 = lean_expr_update_let(x_142, x_119, x_122, x_140); +x_144 = lean_ctor_get(x_141, 0); +lean_inc(x_144); +x_145 = lean_ctor_get(x_141, 1); lean_inc(x_145); -lean_dec(x_137); -x_146 = lean_expr_update_let(x_3, x_129, x_132, x_136); -lean_inc(x_146); -x_147 = lean_array_uset(x_145, x_6, x_146); -x_148 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_148, 0, x_139); -lean_ctor_set(x_148, 1, x_147); -lean_ctor_set(x_134, 1, x_148); -lean_ctor_set(x_134, 0, x_146); -return x_134; -} -else -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; -lean_dec(x_3); -x_149 = lean_ctor_get(x_137, 1); -lean_inc(x_149); -lean_dec(x_137); -x_150 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_150, 0, x_123); -lean_ctor_set(x_150, 1, x_124); -lean_ctor_set(x_150, 2, x_125); -lean_ctor_set(x_150, 3, x_126); -lean_ctor_set_uint64(x_150, sizeof(void*)*4, x_127); -x_151 = lean_expr_update_let(x_150, x_129, x_132, x_136); -lean_inc(x_151); -x_152 = lean_array_uset(x_149, x_6, x_151); -x_153 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_153, 0, x_139); -lean_ctor_set(x_153, 1, x_152); -lean_ctor_set(x_134, 1, x_153); -lean_ctor_set(x_134, 0, x_151); -return x_134; -} -} -else -{ -lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; -x_154 = lean_ctor_get(x_134, 0); -x_155 = lean_ctor_get(x_134, 1); -lean_inc(x_155); -lean_inc(x_154); -lean_dec(x_134); -x_156 = lean_ctor_get(x_155, 0); -lean_inc(x_156); -lean_inc(x_3); -x_157 = lean_array_uset(x_156, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - x_158 = x_3; +if (lean_is_exclusive(x_141)) { + lean_ctor_release(x_141, 0); + lean_ctor_release(x_141, 1); + x_146 = x_141; } else { - lean_dec_ref(x_3); - x_158 = lean_box(0); + lean_dec_ref(x_141); + x_146 = lean_box(0); } -x_159 = lean_ctor_get(x_155, 1); -lean_inc(x_159); -lean_dec(x_155); -if (lean_is_scalar(x_158)) { - x_160 = lean_alloc_ctor(8, 4, 8); +x_147 = lean_array_uset(x_144, x_6, x_3); +lean_inc(x_143); +x_148 = lean_array_uset(x_145, x_6, x_143); +if (lean_is_scalar(x_146)) { + x_149 = lean_alloc_ctor(0, 2, 0); } else { - x_160 = x_158; + x_149 = x_146; } -lean_ctor_set(x_160, 0, x_123); -lean_ctor_set(x_160, 1, x_124); -lean_ctor_set(x_160, 2, x_125); -lean_ctor_set(x_160, 3, x_126); -lean_ctor_set_uint64(x_160, sizeof(void*)*4, x_127); -x_161 = lean_expr_update_let(x_160, x_129, x_132, x_154); -lean_inc(x_161); -x_162 = lean_array_uset(x_159, x_6, x_161); -x_163 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_163, 0, x_157); -lean_ctor_set(x_163, 1, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_161); -lean_ctor_set(x_164, 1, x_163); -return x_164; +lean_ctor_set(x_149, 0, x_147); +lean_ctor_set(x_149, 1, x_148); +x_150 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_150, 0, x_143); +lean_ctor_set(x_150, 1, x_149); +return x_150; } } case 10: { -lean_object* x_165; lean_object* x_166; uint64_t x_167; lean_object* x_168; uint8_t x_169; -x_165 = lean_ctor_get(x_3, 0); +lean_object* x_151; lean_object* x_152; uint64_t x_153; lean_object* x_154; uint8_t x_155; +x_151 = lean_ctor_get(x_3, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_3, 1); +lean_inc(x_152); +x_153 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); +lean_inc(x_152); +x_154 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_152, x_4); +x_155 = !lean_is_exclusive(x_154); +if (x_155 == 0) +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; uint8_t x_160; +x_156 = lean_ctor_get(x_154, 0); +x_157 = lean_ctor_get(x_154, 1); +x_158 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_158, 0, x_151); +lean_ctor_set(x_158, 1, x_152); +lean_ctor_set_uint64(x_158, sizeof(void*)*2, x_153); +x_159 = lean_expr_update_mdata(x_158, x_156); +x_160 = !lean_is_exclusive(x_157); +if (x_160 == 0) +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_157, 0); +x_162 = lean_ctor_get(x_157, 1); +x_163 = lean_array_uset(x_161, x_6, x_3); +lean_inc(x_159); +x_164 = lean_array_uset(x_162, x_6, x_159); +lean_ctor_set(x_157, 1, x_164); +lean_ctor_set(x_157, 0, x_163); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +else +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_165 = lean_ctor_get(x_157, 0); +x_166 = lean_ctor_get(x_157, 1); +lean_inc(x_166); lean_inc(x_165); -x_166 = lean_ctor_get(x_3, 1); -lean_inc(x_166); -x_167 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); -lean_inc(x_166); -x_168 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_166, x_4); -x_169 = !lean_is_exclusive(x_168); -if (x_169 == 0) +lean_dec(x_157); +x_167 = lean_array_uset(x_165, x_6, x_3); +lean_inc(x_159); +x_168 = lean_array_uset(x_166, x_6, x_159); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_167); +lean_ctor_set(x_169, 1, x_168); +lean_ctor_set(x_154, 1, x_169); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +} +else { -lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; -x_170 = lean_ctor_get(x_168, 0); -x_171 = lean_ctor_get(x_168, 1); -x_172 = lean_ctor_get(x_171, 0); -lean_inc(x_172); -lean_inc(x_3); -x_173 = lean_array_uset(x_172, x_6, x_3); -x_174 = !lean_is_exclusive(x_3); -if (x_174 == 0) -{ -lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; -x_175 = lean_ctor_get(x_3, 1); -lean_dec(x_175); -x_176 = lean_ctor_get(x_3, 0); -lean_dec(x_176); -x_177 = lean_ctor_get(x_171, 1); -lean_inc(x_177); -lean_dec(x_171); -x_178 = lean_expr_update_mdata(x_3, x_170); -lean_inc(x_178); -x_179 = lean_array_uset(x_177, x_6, x_178); +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_170 = lean_ctor_get(x_154, 0); +x_171 = lean_ctor_get(x_154, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_154); +x_172 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_172, 0, x_151); +lean_ctor_set(x_172, 1, x_152); +lean_ctor_set_uint64(x_172, sizeof(void*)*2, x_153); +x_173 = lean_expr_update_mdata(x_172, x_170); +x_174 = lean_ctor_get(x_171, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_171, 1); +lean_inc(x_175); +if (lean_is_exclusive(x_171)) { + lean_ctor_release(x_171, 0); + lean_ctor_release(x_171, 1); + x_176 = x_171; +} else { + lean_dec_ref(x_171); + x_176 = lean_box(0); +} +x_177 = lean_array_uset(x_174, x_6, x_3); +lean_inc(x_173); +x_178 = lean_array_uset(x_175, x_6, x_173); +if (lean_is_scalar(x_176)) { + x_179 = lean_alloc_ctor(0, 2, 0); +} else { + x_179 = x_176; +} +lean_ctor_set(x_179, 0, x_177); +lean_ctor_set(x_179, 1, x_178); x_180 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_180, 0, x_173); lean_ctor_set(x_180, 1, x_179); -lean_ctor_set(x_168, 1, x_180); -lean_ctor_set(x_168, 0, x_178); -return x_168; -} -else -{ -lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; -lean_dec(x_3); -x_181 = lean_ctor_get(x_171, 1); -lean_inc(x_181); -lean_dec(x_171); -x_182 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_182, 0, x_165); -lean_ctor_set(x_182, 1, x_166); -lean_ctor_set_uint64(x_182, sizeof(void*)*2, x_167); -x_183 = lean_expr_update_mdata(x_182, x_170); -lean_inc(x_183); -x_184 = lean_array_uset(x_181, x_6, x_183); -x_185 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_185, 0, x_173); -lean_ctor_set(x_185, 1, x_184); -lean_ctor_set(x_168, 1, x_185); -lean_ctor_set(x_168, 0, x_183); -return x_168; -} -} -else -{ -lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; -x_186 = lean_ctor_get(x_168, 0); -x_187 = lean_ctor_get(x_168, 1); -lean_inc(x_187); -lean_inc(x_186); -lean_dec(x_168); -x_188 = lean_ctor_get(x_187, 0); -lean_inc(x_188); -lean_inc(x_3); -x_189 = lean_array_uset(x_188, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_190 = x_3; -} else { - lean_dec_ref(x_3); - x_190 = lean_box(0); -} -x_191 = lean_ctor_get(x_187, 1); -lean_inc(x_191); -lean_dec(x_187); -if (lean_is_scalar(x_190)) { - x_192 = lean_alloc_ctor(10, 2, 8); -} else { - x_192 = x_190; -} -lean_ctor_set(x_192, 0, x_165); -lean_ctor_set(x_192, 1, x_166); -lean_ctor_set_uint64(x_192, sizeof(void*)*2, x_167); -x_193 = lean_expr_update_mdata(x_192, x_186); -lean_inc(x_193); -x_194 = lean_array_uset(x_191, x_6, x_193); -x_195 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_195, 0, x_189); -lean_ctor_set(x_195, 1, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_193); -lean_ctor_set(x_196, 1, x_195); -return x_196; +return x_180; } } case 11: { -lean_object* x_197; lean_object* x_198; lean_object* x_199; uint64_t x_200; lean_object* x_201; uint8_t x_202; -x_197 = lean_ctor_get(x_3, 0); +lean_object* x_181; lean_object* x_182; lean_object* x_183; uint64_t x_184; lean_object* x_185; uint8_t x_186; +x_181 = lean_ctor_get(x_3, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_3, 1); +lean_inc(x_182); +x_183 = lean_ctor_get(x_3, 2); +lean_inc(x_183); +x_184 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_183); +x_185 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_183, x_4); +x_186 = !lean_is_exclusive(x_185); +if (x_186 == 0) +{ +lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; +x_187 = lean_ctor_get(x_185, 0); +x_188 = lean_ctor_get(x_185, 1); +x_189 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_189, 0, x_181); +lean_ctor_set(x_189, 1, x_182); +lean_ctor_set(x_189, 2, x_183); +lean_ctor_set_uint64(x_189, sizeof(void*)*3, x_184); +x_190 = lean_expr_update_proj(x_189, x_187); +x_191 = !lean_is_exclusive(x_188); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; +x_192 = lean_ctor_get(x_188, 0); +x_193 = lean_ctor_get(x_188, 1); +x_194 = lean_array_uset(x_192, x_6, x_3); +lean_inc(x_190); +x_195 = lean_array_uset(x_193, x_6, x_190); +lean_ctor_set(x_188, 1, x_195); +lean_ctor_set(x_188, 0, x_194); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +else +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +x_196 = lean_ctor_get(x_188, 0); +x_197 = lean_ctor_get(x_188, 1); lean_inc(x_197); -x_198 = lean_ctor_get(x_3, 1); -lean_inc(x_198); -x_199 = lean_ctor_get(x_3, 2); -lean_inc(x_199); -x_200 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_199); -x_201 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_Meta_FVarSubst_apply___spec__1(x_1, x_2, x_199, x_4); -x_202 = !lean_is_exclusive(x_201); -if (x_202 == 0) +lean_inc(x_196); +lean_dec(x_188); +x_198 = lean_array_uset(x_196, x_6, x_3); +lean_inc(x_190); +x_199 = lean_array_uset(x_197, x_6, x_190); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_198); +lean_ctor_set(x_200, 1, x_199); +lean_ctor_set(x_185, 1, x_200); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +} +else { -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_201, 0); -x_204 = lean_ctor_get(x_201, 1); -x_205 = lean_ctor_get(x_204, 0); +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; lean_object* x_211; +x_201 = lean_ctor_get(x_185, 0); +x_202 = lean_ctor_get(x_185, 1); +lean_inc(x_202); +lean_inc(x_201); +lean_dec(x_185); +x_203 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_203, 0, x_181); +lean_ctor_set(x_203, 1, x_182); +lean_ctor_set(x_203, 2, x_183); +lean_ctor_set_uint64(x_203, sizeof(void*)*3, x_184); +x_204 = lean_expr_update_proj(x_203, x_201); +x_205 = lean_ctor_get(x_202, 0); lean_inc(x_205); -lean_inc(x_3); -x_206 = lean_array_uset(x_205, x_6, x_3); -x_207 = !lean_is_exclusive(x_3); -if (x_207 == 0) -{ -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; -x_208 = lean_ctor_get(x_3, 2); -lean_dec(x_208); -x_209 = lean_ctor_get(x_3, 1); -lean_dec(x_209); -x_210 = lean_ctor_get(x_3, 0); -lean_dec(x_210); -x_211 = lean_ctor_get(x_204, 1); -lean_inc(x_211); -lean_dec(x_204); -x_212 = lean_expr_update_proj(x_3, x_203); -lean_inc(x_212); -x_213 = lean_array_uset(x_211, x_6, x_212); -x_214 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_214, 0, x_206); -lean_ctor_set(x_214, 1, x_213); -lean_ctor_set(x_201, 1, x_214); -lean_ctor_set(x_201, 0, x_212); -return x_201; -} -else -{ -lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; -lean_dec(x_3); -x_215 = lean_ctor_get(x_204, 1); -lean_inc(x_215); -lean_dec(x_204); -x_216 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_216, 0, x_197); -lean_ctor_set(x_216, 1, x_198); -lean_ctor_set(x_216, 2, x_199); -lean_ctor_set_uint64(x_216, sizeof(void*)*3, x_200); -x_217 = lean_expr_update_proj(x_216, x_203); -lean_inc(x_217); -x_218 = lean_array_uset(x_215, x_6, x_217); -x_219 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_219, 0, x_206); -lean_ctor_set(x_219, 1, x_218); -lean_ctor_set(x_201, 1, x_219); -lean_ctor_set(x_201, 0, x_217); -return x_201; -} -} -else -{ -lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; -x_220 = lean_ctor_get(x_201, 0); -x_221 = lean_ctor_get(x_201, 1); -lean_inc(x_221); -lean_inc(x_220); -lean_dec(x_201); -x_222 = lean_ctor_get(x_221, 0); -lean_inc(x_222); -lean_inc(x_3); -x_223 = lean_array_uset(x_222, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_224 = x_3; +x_206 = lean_ctor_get(x_202, 1); +lean_inc(x_206); +if (lean_is_exclusive(x_202)) { + lean_ctor_release(x_202, 0); + lean_ctor_release(x_202, 1); + x_207 = x_202; } else { - lean_dec_ref(x_3); - x_224 = lean_box(0); + lean_dec_ref(x_202); + x_207 = lean_box(0); } -x_225 = lean_ctor_get(x_221, 1); -lean_inc(x_225); -lean_dec(x_221); -if (lean_is_scalar(x_224)) { - x_226 = lean_alloc_ctor(11, 3, 8); +x_208 = lean_array_uset(x_205, x_6, x_3); +lean_inc(x_204); +x_209 = lean_array_uset(x_206, x_6, x_204); +if (lean_is_scalar(x_207)) { + x_210 = lean_alloc_ctor(0, 2, 0); } else { - x_226 = x_224; + x_210 = x_207; } -lean_ctor_set(x_226, 0, x_197); -lean_ctor_set(x_226, 1, x_198); -lean_ctor_set(x_226, 2, x_199); -lean_ctor_set_uint64(x_226, sizeof(void*)*3, x_200); -x_227 = lean_expr_update_proj(x_226, x_220); -lean_inc(x_227); -x_228 = lean_array_uset(x_225, x_6, x_227); -x_229 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_229, 0, x_223); -lean_ctor_set(x_229, 1, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_227); -lean_ctor_set(x_230, 1, x_229); -return x_230; +lean_ctor_set(x_210, 0, x_208); +lean_ctor_set(x_210, 1, x_209); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_204); +lean_ctor_set(x_211, 1, x_210); +return x_211; } } default: { -lean_object* x_231; -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_3); -lean_ctor_set(x_231, 1, x_4); -return x_231; +lean_object* x_212; +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_3); +lean_ctor_set(x_212, 1, x_4); +return x_212; } } } -block_240: +block_227: { -lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; -x_235 = lean_array_uset(x_233, x_6, x_3); -x_236 = lean_ctor_get(x_4, 1); -lean_inc(x_236); +uint8_t x_215; +x_215 = !lean_is_exclusive(x_4); +if (x_215 == 0) +{ +lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; lean_object* x_220; +x_216 = lean_ctor_get(x_4, 0); +x_217 = lean_ctor_get(x_4, 1); +x_218 = lean_array_uset(x_216, x_6, x_3); +lean_inc(x_214); +x_219 = lean_array_uset(x_217, x_6, x_214); +lean_ctor_set(x_4, 1, x_219); +lean_ctor_set(x_4, 0, x_218); +x_220 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_220, 0, x_214); +lean_ctor_set(x_220, 1, x_4); +return x_220; +} +else +{ +lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; +x_221 = lean_ctor_get(x_4, 0); +x_222 = lean_ctor_get(x_4, 1); +lean_inc(x_222); +lean_inc(x_221); lean_dec(x_4); -lean_inc(x_234); -x_237 = lean_array_uset(x_236, x_6, x_234); -x_238 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_238, 0, x_235); -lean_ctor_set(x_238, 1, x_237); -x_239 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_239, 0, x_234); -lean_ctor_set(x_239, 1, x_238); -return x_239; +x_223 = lean_array_uset(x_221, x_6, x_3); +lean_inc(x_214); +x_224 = lean_array_uset(x_222, x_6, x_214); +x_225 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_225, 0, x_223); +lean_ctor_set(x_225, 1, x_224); +x_226 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_226, 0, x_214); +lean_ctor_set(x_226, 1, x_225); +return x_226; +} } } } diff --git a/stage0/stdlib/Lean/ParserCompiler.c b/stage0/stdlib/Lean/ParserCompiler.c index c316e7539d..f5c8121c61 100644 --- a/stage0/stdlib/Lean/ParserCompiler.c +++ b/stage0/stdlib/Lean/ParserCompiler.c @@ -224,107 +224,149 @@ return x_2; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(lean_object* x_1, size_t x_2, lean_object* x_3, lean_object* x_4) { _start: { -size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_233; lean_object* x_234; size_t x_235; uint8_t x_236; +size_t x_5; size_t x_6; lean_object* x_7; lean_object* x_214; lean_object* x_215; size_t x_216; uint8_t x_217; x_5 = lean_ptr_addr(x_3); x_6 = x_2 == 0 ? x_5 : x_5 % x_2; -x_233 = lean_ctor_get(x_4, 0); -lean_inc(x_233); -x_234 = lean_array_uget(x_233, x_6); -x_235 = lean_ptr_addr(x_234); -lean_dec(x_234); -x_236 = x_235 == x_5; -if (x_236 == 0) +x_214 = lean_ctor_get(x_4, 0); +lean_inc(x_214); +x_215 = lean_array_uget(x_214, x_6); +lean_dec(x_214); +x_216 = lean_ptr_addr(x_215); +lean_dec(x_215); +x_217 = x_216 == x_5; +if (x_217 == 0) { -uint8_t x_237; -x_237 = l_Lean_Expr_isOptParam(x_3); -if (x_237 == 0) +uint8_t x_218; +x_218 = l_Lean_Expr_isOptParam(x_3); +if (x_218 == 0) { -lean_object* x_238; uint8_t x_239; -x_238 = l_Lean_Parser_evalParserConstUnsafe___closed__1; -x_239 = l_Lean_Expr_isConstOf(x_3, x_238); -if (x_239 == 0) +lean_object* x_219; uint8_t x_220; +x_219 = l_Lean_Parser_evalParserConstUnsafe___closed__1; +x_220 = l_Lean_Expr_isConstOf(x_3, x_219); +if (x_220 == 0) { -lean_object* x_240; -lean_dec(x_233); -x_240 = lean_box(0); -x_7 = x_240; -goto block_232; +lean_object* x_221; +x_221 = lean_box(0); +x_7 = x_221; +goto block_213; } 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; -x_241 = l_Lean_ParserCompiler_Context_tyName___rarg(x_1); -x_242 = lean_box(0); -x_243 = l_Lean_mkConst(x_241, x_242); -x_244 = lean_array_uset(x_233, x_6, x_3); -x_245 = lean_ctor_get(x_4, 1); -lean_inc(x_245); +lean_object* x_222; lean_object* x_223; lean_object* x_224; uint8_t x_225; +x_222 = l_Lean_ParserCompiler_Context_tyName___rarg(x_1); +x_223 = lean_box(0); +x_224 = l_Lean_mkConst(x_222, x_223); +x_225 = !lean_is_exclusive(x_4); +if (x_225 == 0) +{ +lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; +x_226 = lean_ctor_get(x_4, 0); +x_227 = lean_ctor_get(x_4, 1); +x_228 = lean_array_uset(x_226, x_6, x_3); +lean_inc(x_224); +x_229 = lean_array_uset(x_227, x_6, x_224); +lean_ctor_set(x_4, 1, x_229); +lean_ctor_set(x_4, 0, x_228); +x_230 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_230, 0, x_224); +lean_ctor_set(x_230, 1, x_4); +return x_230; +} +else +{ +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; +x_231 = lean_ctor_get(x_4, 0); +x_232 = lean_ctor_get(x_4, 1); +lean_inc(x_232); +lean_inc(x_231); lean_dec(x_4); -lean_inc(x_243); -x_246 = lean_array_uset(x_245, x_6, x_243); -x_247 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_247, 0, x_244); -lean_ctor_set(x_247, 1, x_246); -x_248 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_248, 0, x_243); -lean_ctor_set(x_248, 1, x_247); -return x_248; +x_233 = lean_array_uset(x_231, x_6, x_3); +lean_inc(x_224); +x_234 = lean_array_uset(x_232, x_6, x_224); +x_235 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_235, 0, x_233); +lean_ctor_set(x_235, 1, x_234); +x_236 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_236, 0, x_224); +lean_ctor_set(x_236, 1, x_235); +return x_236; +} } } else { -lean_object* x_249; lean_object* x_250; lean_object* x_251; uint8_t x_252; -x_249 = l_Lean_Expr_appFn_x21(x_3); -x_250 = l_Lean_Expr_appArg_x21(x_249); -lean_dec(x_249); -x_251 = l_Lean_Parser_evalParserConstUnsafe___closed__1; -x_252 = l_Lean_Expr_isConstOf(x_250, x_251); -lean_dec(x_250); -if (x_252 == 0) +lean_object* x_237; lean_object* x_238; lean_object* x_239; uint8_t x_240; +x_237 = l_Lean_Expr_appFn_x21(x_3); +x_238 = l_Lean_Expr_appArg_x21(x_237); +lean_dec(x_237); +x_239 = l_Lean_Parser_evalParserConstUnsafe___closed__1; +x_240 = l_Lean_Expr_isConstOf(x_238, x_239); +lean_dec(x_238); +if (x_240 == 0) { -lean_object* x_253; -lean_dec(x_233); -x_253 = lean_box(0); -x_7 = x_253; -goto block_232; +lean_object* x_241; +x_241 = lean_box(0); +x_7 = x_241; +goto block_213; } else { -lean_object* x_254; lean_object* x_255; lean_object* x_256; lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_object* x_260; lean_object* x_261; -x_254 = l_Lean_ParserCompiler_Context_tyName___rarg(x_1); -x_255 = lean_box(0); -x_256 = l_Lean_mkConst(x_254, x_255); -x_257 = lean_array_uset(x_233, x_6, x_3); -x_258 = lean_ctor_get(x_4, 1); -lean_inc(x_258); +lean_object* x_242; lean_object* x_243; lean_object* x_244; uint8_t x_245; +x_242 = l_Lean_ParserCompiler_Context_tyName___rarg(x_1); +x_243 = lean_box(0); +x_244 = l_Lean_mkConst(x_242, x_243); +x_245 = !lean_is_exclusive(x_4); +if (x_245 == 0) +{ +lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; +x_246 = lean_ctor_get(x_4, 0); +x_247 = lean_ctor_get(x_4, 1); +x_248 = lean_array_uset(x_246, x_6, x_3); +lean_inc(x_244); +x_249 = lean_array_uset(x_247, x_6, x_244); +lean_ctor_set(x_4, 1, x_249); +lean_ctor_set(x_4, 0, x_248); +x_250 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_250, 0, x_244); +lean_ctor_set(x_250, 1, x_4); +return x_250; +} +else +{ +lean_object* x_251; lean_object* x_252; lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; +x_251 = lean_ctor_get(x_4, 0); +x_252 = lean_ctor_get(x_4, 1); +lean_inc(x_252); +lean_inc(x_251); lean_dec(x_4); -lean_inc(x_256); -x_259 = lean_array_uset(x_258, x_6, x_256); -x_260 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_260, 0, x_257); -lean_ctor_set(x_260, 1, x_259); -x_261 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_261, 0, x_256); -lean_ctor_set(x_261, 1, x_260); -return x_261; +x_253 = lean_array_uset(x_251, x_6, x_3); +lean_inc(x_244); +x_254 = lean_array_uset(x_252, x_6, x_244); +x_255 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_255, 0, x_253); +lean_ctor_set(x_255, 1, x_254); +x_256 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_256, 0, x_244); +lean_ctor_set(x_256, 1, x_255); +return x_256; +} } } } else { -lean_object* x_262; lean_object* x_263; lean_object* x_264; -lean_dec(x_233); +lean_object* x_257; lean_object* x_258; lean_object* x_259; lean_dec(x_3); -x_262 = lean_ctor_get(x_4, 1); -lean_inc(x_262); -x_263 = lean_array_uget(x_262, x_6); -lean_dec(x_262); -x_264 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_264, 0, x_263); -lean_ctor_set(x_264, 1, x_4); -return x_264; +x_257 = lean_ctor_get(x_4, 1); +lean_inc(x_257); +x_258 = lean_array_uget(x_257, x_6); +lean_dec(x_257); +x_259 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_259, 0, x_258); +lean_ctor_set(x_259, 1, x_4); +return x_259; } -block_232: +block_213: { lean_dec(x_7); switch (lean_obj_tag(x_3)) { @@ -351,702 +393,619 @@ 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_14, 0); x_17 = lean_ctor_get(x_14, 1); -x_18 = lean_ctor_get(x_17, 0); -lean_inc(x_18); -lean_inc(x_3); -x_19 = lean_array_uset(x_18, x_6, x_3); -x_20 = !lean_is_exclusive(x_3); +x_18 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_18, 0, x_8); +lean_ctor_set(x_18, 1, x_9); +lean_ctor_set_uint64(x_18, sizeof(void*)*2, x_10); +x_19 = lean_expr_update_app(x_18, x_12, x_16); +x_20 = !lean_is_exclusive(x_17); if (x_20 == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -x_21 = lean_ctor_get(x_3, 1); -lean_dec(x_21); -x_22 = lean_ctor_get(x_3, 0); -lean_dec(x_22); -x_23 = lean_ctor_get(x_17, 1); -lean_inc(x_23); -lean_dec(x_17); -x_24 = lean_expr_update_app(x_3, x_12, x_16); -lean_inc(x_24); -x_25 = lean_array_uset(x_23, x_6, x_24); -x_26 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_26, 0, x_19); -lean_ctor_set(x_26, 1, x_25); -lean_ctor_set(x_14, 1, x_26); -lean_ctor_set(x_14, 0, x_24); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_21 = lean_ctor_get(x_17, 0); +x_22 = lean_ctor_get(x_17, 1); +x_23 = lean_array_uset(x_21, x_6, x_3); +lean_inc(x_19); +x_24 = lean_array_uset(x_22, x_6, x_19); +lean_ctor_set(x_17, 1, x_24); +lean_ctor_set(x_17, 0, x_23); +lean_ctor_set(x_14, 0, x_19); return x_14; } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -lean_dec(x_3); -x_27 = lean_ctor_get(x_17, 1); -lean_inc(x_27); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_25 = lean_ctor_get(x_17, 0); +x_26 = lean_ctor_get(x_17, 1); +lean_inc(x_26); +lean_inc(x_25); lean_dec(x_17); -x_28 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_28, 0, x_8); -lean_ctor_set(x_28, 1, x_9); -lean_ctor_set_uint64(x_28, sizeof(void*)*2, x_10); -x_29 = lean_expr_update_app(x_28, x_12, x_16); -lean_inc(x_29); -x_30 = lean_array_uset(x_27, x_6, x_29); -x_31 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_31, 0, x_19); -lean_ctor_set(x_31, 1, x_30); -lean_ctor_set(x_14, 1, x_31); -lean_ctor_set(x_14, 0, x_29); +x_27 = lean_array_uset(x_25, x_6, x_3); +lean_inc(x_19); +x_28 = lean_array_uset(x_26, x_6, x_19); +x_29 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_14, 1, x_29); +lean_ctor_set(x_14, 0, x_19); return x_14; } } 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_14, 0); -x_33 = lean_ctor_get(x_14, 1); -lean_inc(x_33); -lean_inc(x_32); +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_30 = lean_ctor_get(x_14, 0); +x_31 = lean_ctor_get(x_14, 1); +lean_inc(x_31); +lean_inc(x_30); lean_dec(x_14); -x_34 = lean_ctor_get(x_33, 0); +x_32 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_32, 0, x_8); +lean_ctor_set(x_32, 1, x_9); +lean_ctor_set_uint64(x_32, sizeof(void*)*2, x_10); +x_33 = lean_expr_update_app(x_32, x_12, x_30); +x_34 = lean_ctor_get(x_31, 0); lean_inc(x_34); -lean_inc(x_3); -x_35 = lean_array_uset(x_34, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_36 = x_3; +x_35 = lean_ctor_get(x_31, 1); +lean_inc(x_35); +if (lean_is_exclusive(x_31)) { + lean_ctor_release(x_31, 0); + lean_ctor_release(x_31, 1); + x_36 = x_31; } else { - lean_dec_ref(x_3); + lean_dec_ref(x_31); x_36 = lean_box(0); } -x_37 = lean_ctor_get(x_33, 1); -lean_inc(x_37); -lean_dec(x_33); +x_37 = lean_array_uset(x_34, x_6, x_3); +lean_inc(x_33); +x_38 = lean_array_uset(x_35, x_6, x_33); if (lean_is_scalar(x_36)) { - x_38 = lean_alloc_ctor(5, 2, 8); + x_39 = lean_alloc_ctor(0, 2, 0); } else { - x_38 = x_36; + x_39 = x_36; } -lean_ctor_set(x_38, 0, x_8); -lean_ctor_set(x_38, 1, x_9); -lean_ctor_set_uint64(x_38, sizeof(void*)*2, x_10); -x_39 = lean_expr_update_app(x_38, x_12, x_32); -lean_inc(x_39); -x_40 = lean_array_uset(x_37, x_6, x_39); -x_41 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_41, 0, x_35); -lean_ctor_set(x_41, 1, x_40); -x_42 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_42, 0, x_39); -lean_ctor_set(x_42, 1, x_41); -return x_42; +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_33); +lean_ctor_set(x_40, 1, x_39); +return x_40; } } case 6: { -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_object* x_49; lean_object* x_50; uint8_t x_51; -x_43 = lean_ctor_get(x_3, 0); +lean_object* x_41; lean_object* x_42; lean_object* x_43; uint64_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_41 = lean_ctor_get(x_3, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_3, 1); +lean_inc(x_42); +x_43 = lean_ctor_get(x_3, 2); lean_inc(x_43); -x_44 = lean_ctor_get(x_3, 1); -lean_inc(x_44); -x_45 = lean_ctor_get(x_3, 2); -lean_inc(x_45); -x_46 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_44); -x_47 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_44, x_4); -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); -lean_inc(x_49); -lean_dec(x_47); -lean_inc(x_45); -x_50 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_45, x_49); -x_51 = !lean_is_exclusive(x_50); -if (x_51 == 0) +x_44 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_42); +x_45 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_42, x_4); +x_46 = lean_ctor_get(x_45, 0); +lean_inc(x_46); +x_47 = lean_ctor_get(x_45, 1); +lean_inc(x_47); +lean_dec(x_45); +lean_inc(x_43); +x_48 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_43, x_47); +x_49 = !lean_is_exclusive(x_48); +if (x_49 == 0) { -lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; uint8_t x_56; -x_52 = lean_ctor_get(x_50, 0); -x_53 = lean_ctor_get(x_50, 1); -x_54 = lean_ctor_get(x_53, 0); +lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; lean_object* x_54; uint8_t x_55; +x_50 = lean_ctor_get(x_48, 0); +x_51 = lean_ctor_get(x_48, 1); +x_52 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_52, 0, x_41); +lean_ctor_set(x_52, 1, x_42); +lean_ctor_set(x_52, 2, x_43); +lean_ctor_set_uint64(x_52, sizeof(void*)*3, x_44); +x_53 = (uint8_t)((x_44 << 24) >> 61); +x_54 = lean_expr_update_lambda(x_52, x_53, x_46, x_50); +x_55 = !lean_is_exclusive(x_51); +if (x_55 == 0) +{ +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_56 = lean_ctor_get(x_51, 0); +x_57 = lean_ctor_get(x_51, 1); +x_58 = lean_array_uset(x_56, x_6, x_3); lean_inc(x_54); -lean_inc(x_3); -x_55 = lean_array_uset(x_54, x_6, x_3); -x_56 = !lean_is_exclusive(x_3); -if (x_56 == 0) +x_59 = lean_array_uset(x_57, x_6, x_54); +lean_ctor_set(x_51, 1, x_59); +lean_ctor_set(x_51, 0, x_58); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} +else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; -x_57 = lean_ctor_get(x_3, 2); -lean_dec(x_57); -x_58 = lean_ctor_get(x_3, 1); -lean_dec(x_58); -x_59 = lean_ctor_get(x_3, 0); -lean_dec(x_59); -x_60 = lean_ctor_get(x_53, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_60 = lean_ctor_get(x_51, 0); +x_61 = lean_ctor_get(x_51, 1); +lean_inc(x_61); lean_inc(x_60); -lean_dec(x_53); -x_61 = (uint8_t)((x_46 << 24) >> 61); -x_62 = lean_expr_update_lambda(x_3, x_61, x_48, x_52); -lean_inc(x_62); -x_63 = lean_array_uset(x_60, x_6, x_62); +lean_dec(x_51); +x_62 = lean_array_uset(x_60, x_6, x_3); +lean_inc(x_54); +x_63 = lean_array_uset(x_61, x_6, x_54); x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_55); +lean_ctor_set(x_64, 0, x_62); lean_ctor_set(x_64, 1, x_63); -lean_ctor_set(x_50, 1, x_64); -lean_ctor_set(x_50, 0, x_62); -return x_50; +lean_ctor_set(x_48, 1, x_64); +lean_ctor_set(x_48, 0, x_54); +return x_48; +} } else { -lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; -lean_dec(x_3); -x_65 = lean_ctor_get(x_53, 1); +lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_65 = lean_ctor_get(x_48, 0); +x_66 = lean_ctor_get(x_48, 1); +lean_inc(x_66); lean_inc(x_65); -lean_dec(x_53); -x_66 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_66, 0, x_43); -lean_ctor_set(x_66, 1, x_44); -lean_ctor_set(x_66, 2, x_45); -lean_ctor_set_uint64(x_66, sizeof(void*)*3, x_46); -x_67 = (uint8_t)((x_46 << 24) >> 61); -x_68 = lean_expr_update_lambda(x_66, x_67, x_48, x_52); -lean_inc(x_68); -x_69 = lean_array_uset(x_65, x_6, x_68); -x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_55); -lean_ctor_set(x_70, 1, x_69); -lean_ctor_set(x_50, 1, x_70); -lean_ctor_set(x_50, 0, x_68); -return x_50; -} -} -else -{ -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_71 = lean_ctor_get(x_50, 0); -x_72 = lean_ctor_get(x_50, 1); -lean_inc(x_72); +lean_dec(x_48); +x_67 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_67, 0, x_41); +lean_ctor_set(x_67, 1, x_42); +lean_ctor_set(x_67, 2, x_43); +lean_ctor_set_uint64(x_67, sizeof(void*)*3, x_44); +x_68 = (uint8_t)((x_44 << 24) >> 61); +x_69 = lean_expr_update_lambda(x_67, x_68, x_46, x_65); +x_70 = lean_ctor_get(x_66, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_66, 1); lean_inc(x_71); -lean_dec(x_50); -x_73 = lean_ctor_get(x_72, 0); -lean_inc(x_73); -lean_inc(x_3); -x_74 = lean_array_uset(x_73, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_75 = x_3; +if (lean_is_exclusive(x_66)) { + lean_ctor_release(x_66, 0); + lean_ctor_release(x_66, 1); + x_72 = x_66; } else { - lean_dec_ref(x_3); - x_75 = lean_box(0); + lean_dec_ref(x_66); + x_72 = lean_box(0); } -x_76 = lean_ctor_get(x_72, 1); -lean_inc(x_76); -lean_dec(x_72); -if (lean_is_scalar(x_75)) { - x_77 = lean_alloc_ctor(6, 3, 8); +x_73 = lean_array_uset(x_70, x_6, x_3); +lean_inc(x_69); +x_74 = lean_array_uset(x_71, x_6, x_69); +if (lean_is_scalar(x_72)) { + x_75 = lean_alloc_ctor(0, 2, 0); } else { - x_77 = x_75; + x_75 = x_72; } -lean_ctor_set(x_77, 0, x_43); -lean_ctor_set(x_77, 1, x_44); -lean_ctor_set(x_77, 2, x_45); -lean_ctor_set_uint64(x_77, sizeof(void*)*3, x_46); -x_78 = (uint8_t)((x_46 << 24) >> 61); -x_79 = lean_expr_update_lambda(x_77, x_78, x_48, x_71); -lean_inc(x_79); -x_80 = lean_array_uset(x_76, x_6, x_79); -x_81 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_81, 0, x_74); -lean_ctor_set(x_81, 1, x_80); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_79); -lean_ctor_set(x_82, 1, x_81); -return x_82; +lean_ctor_set(x_75, 0, x_73); +lean_ctor_set(x_75, 1, x_74); +x_76 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_76, 0, x_69); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } case 7: { -lean_object* x_83; lean_object* x_84; lean_object* x_85; uint64_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; uint8_t x_91; -x_83 = lean_ctor_get(x_3, 0); +lean_object* x_77; lean_object* x_78; lean_object* x_79; uint64_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; uint8_t x_85; +x_77 = lean_ctor_get(x_3, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_3, 1); +lean_inc(x_78); +x_79 = lean_ctor_get(x_3, 2); +lean_inc(x_79); +x_80 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_78); +x_81 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_78, x_4); +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); lean_inc(x_83); -x_84 = lean_ctor_get(x_3, 1); -lean_inc(x_84); -x_85 = lean_ctor_get(x_3, 2); -lean_inc(x_85); -x_86 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_84); -x_87 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_84, x_4); -x_88 = lean_ctor_get(x_87, 0); -lean_inc(x_88); -x_89 = lean_ctor_get(x_87, 1); -lean_inc(x_89); -lean_dec(x_87); -lean_inc(x_85); -x_90 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_85, x_89); -x_91 = !lean_is_exclusive(x_90); +lean_dec(x_81); +lean_inc(x_79); +x_84 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_79, x_83); +x_85 = !lean_is_exclusive(x_84); +if (x_85 == 0) +{ +lean_object* x_86; lean_object* x_87; lean_object* x_88; uint8_t x_89; lean_object* x_90; uint8_t x_91; +x_86 = lean_ctor_get(x_84, 0); +x_87 = lean_ctor_get(x_84, 1); +x_88 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_88, 0, x_77); +lean_ctor_set(x_88, 1, x_78); +lean_ctor_set(x_88, 2, x_79); +lean_ctor_set_uint64(x_88, sizeof(void*)*3, x_80); +x_89 = (uint8_t)((x_80 << 24) >> 61); +x_90 = lean_expr_update_forall(x_88, x_89, x_82, x_86); +x_91 = !lean_is_exclusive(x_87); if (x_91 == 0) { -lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; uint8_t x_96; -x_92 = lean_ctor_get(x_90, 0); -x_93 = lean_ctor_get(x_90, 1); -x_94 = lean_ctor_get(x_93, 0); -lean_inc(x_94); -lean_inc(x_3); -x_95 = lean_array_uset(x_94, x_6, x_3); -x_96 = !lean_is_exclusive(x_3); -if (x_96 == 0) +lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_92 = lean_ctor_get(x_87, 0); +x_93 = lean_ctor_get(x_87, 1); +x_94 = lean_array_uset(x_92, x_6, x_3); +lean_inc(x_90); +x_95 = lean_array_uset(x_93, x_6, x_90); +lean_ctor_set(x_87, 1, x_95); +lean_ctor_set(x_87, 0, x_94); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; -x_97 = lean_ctor_get(x_3, 2); -lean_dec(x_97); -x_98 = lean_ctor_get(x_3, 1); -lean_dec(x_98); -x_99 = lean_ctor_get(x_3, 0); -lean_dec(x_99); -x_100 = lean_ctor_get(x_93, 1); -lean_inc(x_100); -lean_dec(x_93); -x_101 = (uint8_t)((x_86 << 24) >> 61); -x_102 = lean_expr_update_forall(x_3, x_101, x_88, x_92); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_96 = lean_ctor_get(x_87, 0); +x_97 = lean_ctor_get(x_87, 1); +lean_inc(x_97); +lean_inc(x_96); +lean_dec(x_87); +x_98 = lean_array_uset(x_96, x_6, x_3); +lean_inc(x_90); +x_99 = lean_array_uset(x_97, x_6, x_90); +x_100 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +lean_ctor_set(x_84, 1, x_100); +lean_ctor_set(x_84, 0, x_90); +return x_84; +} +} +else +{ +lean_object* x_101; lean_object* x_102; lean_object* x_103; uint8_t x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_101 = lean_ctor_get(x_84, 0); +x_102 = lean_ctor_get(x_84, 1); lean_inc(x_102); -x_103 = lean_array_uset(x_100, x_6, x_102); -x_104 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_104, 0, x_95); -lean_ctor_set(x_104, 1, x_103); -lean_ctor_set(x_90, 1, x_104); -lean_ctor_set(x_90, 0, x_102); -return x_90; +lean_inc(x_101); +lean_dec(x_84); +x_103 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_103, 0, x_77); +lean_ctor_set(x_103, 1, x_78); +lean_ctor_set(x_103, 2, x_79); +lean_ctor_set_uint64(x_103, sizeof(void*)*3, x_80); +x_104 = (uint8_t)((x_80 << 24) >> 61); +x_105 = lean_expr_update_forall(x_103, x_104, x_82, x_101); +x_106 = lean_ctor_get(x_102, 0); +lean_inc(x_106); +x_107 = lean_ctor_get(x_102, 1); +lean_inc(x_107); +if (lean_is_exclusive(x_102)) { + lean_ctor_release(x_102, 0); + lean_ctor_release(x_102, 1); + x_108 = x_102; +} else { + lean_dec_ref(x_102); + x_108 = lean_box(0); } -else -{ -lean_object* x_105; lean_object* x_106; uint8_t x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; -lean_dec(x_3); -x_105 = lean_ctor_get(x_93, 1); +x_109 = lean_array_uset(x_106, x_6, x_3); lean_inc(x_105); -lean_dec(x_93); -x_106 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_106, 0, x_83); -lean_ctor_set(x_106, 1, x_84); -lean_ctor_set(x_106, 2, x_85); -lean_ctor_set_uint64(x_106, sizeof(void*)*3, x_86); -x_107 = (uint8_t)((x_86 << 24) >> 61); -x_108 = lean_expr_update_forall(x_106, x_107, x_88, x_92); -lean_inc(x_108); -x_109 = lean_array_uset(x_105, x_6, x_108); -x_110 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_110, 0, x_95); -lean_ctor_set(x_110, 1, x_109); -lean_ctor_set(x_90, 1, x_110); -lean_ctor_set(x_90, 0, x_108); -return x_90; -} -} -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; uint8_t x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; -x_111 = lean_ctor_get(x_90, 0); -x_112 = lean_ctor_get(x_90, 1); -lean_inc(x_112); -lean_inc(x_111); -lean_dec(x_90); -x_113 = lean_ctor_get(x_112, 0); -lean_inc(x_113); -lean_inc(x_3); -x_114 = lean_array_uset(x_113, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_115 = x_3; +x_110 = lean_array_uset(x_107, x_6, x_105); +if (lean_is_scalar(x_108)) { + x_111 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_3); - x_115 = lean_box(0); + x_111 = x_108; } -x_116 = lean_ctor_get(x_112, 1); -lean_inc(x_116); -lean_dec(x_112); -if (lean_is_scalar(x_115)) { - x_117 = lean_alloc_ctor(7, 3, 8); -} else { - x_117 = x_115; -} -lean_ctor_set(x_117, 0, x_83); -lean_ctor_set(x_117, 1, x_84); -lean_ctor_set(x_117, 2, x_85); -lean_ctor_set_uint64(x_117, sizeof(void*)*3, x_86); -x_118 = (uint8_t)((x_86 << 24) >> 61); -x_119 = lean_expr_update_forall(x_117, x_118, x_88, x_111); -lean_inc(x_119); -x_120 = lean_array_uset(x_116, x_6, x_119); -x_121 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_121, 0, x_114); -lean_ctor_set(x_121, 1, x_120); -x_122 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_122, 0, x_119); -lean_ctor_set(x_122, 1, x_121); -return x_122; +lean_ctor_set(x_111, 0, x_109); +lean_ctor_set(x_111, 1, x_110); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_105); +lean_ctor_set(x_112, 1, x_111); +return x_112; } } case 8: { -lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; uint64_t 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; uint8_t x_135; -x_123 = lean_ctor_get(x_3, 0); +lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; uint64_t 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; uint8_t x_125; +x_113 = lean_ctor_get(x_3, 0); +lean_inc(x_113); +x_114 = lean_ctor_get(x_3, 1); +lean_inc(x_114); +x_115 = lean_ctor_get(x_3, 2); +lean_inc(x_115); +x_116 = lean_ctor_get(x_3, 3); +lean_inc(x_116); +x_117 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); +lean_inc(x_114); +x_118 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_114, x_4); +x_119 = lean_ctor_get(x_118, 0); +lean_inc(x_119); +x_120 = lean_ctor_get(x_118, 1); +lean_inc(x_120); +lean_dec(x_118); +lean_inc(x_115); +x_121 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_115, x_120); +x_122 = lean_ctor_get(x_121, 0); +lean_inc(x_122); +x_123 = lean_ctor_get(x_121, 1); lean_inc(x_123); -x_124 = lean_ctor_get(x_3, 1); -lean_inc(x_124); -x_125 = lean_ctor_get(x_3, 2); -lean_inc(x_125); -x_126 = lean_ctor_get(x_3, 3); -lean_inc(x_126); -x_127 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); -lean_inc(x_124); -x_128 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_124, x_4); -x_129 = lean_ctor_get(x_128, 0); +lean_dec(x_121); +lean_inc(x_116); +x_124 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_116, x_123); +x_125 = !lean_is_exclusive(x_124); +if (x_125 == 0) +{ +lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; +x_126 = lean_ctor_get(x_124, 0); +x_127 = lean_ctor_get(x_124, 1); +x_128 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_128, 0, x_113); +lean_ctor_set(x_128, 1, x_114); +lean_ctor_set(x_128, 2, x_115); +lean_ctor_set(x_128, 3, x_116); +lean_ctor_set_uint64(x_128, sizeof(void*)*4, x_117); +x_129 = lean_expr_update_let(x_128, x_119, x_122, x_126); +x_130 = !lean_is_exclusive(x_127); +if (x_130 == 0) +{ +lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_131 = lean_ctor_get(x_127, 0); +x_132 = lean_ctor_get(x_127, 1); +x_133 = lean_array_uset(x_131, x_6, x_3); lean_inc(x_129); -x_130 = lean_ctor_get(x_128, 1); -lean_inc(x_130); -lean_dec(x_128); -lean_inc(x_125); -x_131 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_125, x_130); -x_132 = lean_ctor_get(x_131, 0); -lean_inc(x_132); -x_133 = lean_ctor_get(x_131, 1); -lean_inc(x_133); -lean_dec(x_131); -lean_inc(x_126); -x_134 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_126, x_133); -x_135 = !lean_is_exclusive(x_134); -if (x_135 == 0) +x_134 = lean_array_uset(x_132, x_6, x_129); +lean_ctor_set(x_127, 1, x_134); +lean_ctor_set(x_127, 0, x_133); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +else { -lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; uint8_t x_140; -x_136 = lean_ctor_get(x_134, 0); -x_137 = lean_ctor_get(x_134, 1); -x_138 = lean_ctor_get(x_137, 0); -lean_inc(x_138); -lean_inc(x_3); -x_139 = lean_array_uset(x_138, x_6, x_3); -x_140 = !lean_is_exclusive(x_3); -if (x_140 == 0) +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; +x_135 = lean_ctor_get(x_127, 0); +x_136 = lean_ctor_get(x_127, 1); +lean_inc(x_136); +lean_inc(x_135); +lean_dec(x_127); +x_137 = lean_array_uset(x_135, x_6, x_3); +lean_inc(x_129); +x_138 = lean_array_uset(x_136, x_6, x_129); +x_139 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_139, 0, x_137); +lean_ctor_set(x_139, 1, x_138); +lean_ctor_set(x_124, 1, x_139); +lean_ctor_set(x_124, 0, x_129); +return x_124; +} +} +else { -lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; -x_141 = lean_ctor_get(x_3, 3); -lean_dec(x_141); -x_142 = lean_ctor_get(x_3, 2); -lean_dec(x_142); -x_143 = lean_ctor_get(x_3, 1); -lean_dec(x_143); -x_144 = lean_ctor_get(x_3, 0); -lean_dec(x_144); -x_145 = lean_ctor_get(x_137, 1); +lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; +x_140 = lean_ctor_get(x_124, 0); +x_141 = lean_ctor_get(x_124, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_124); +x_142 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_142, 0, x_113); +lean_ctor_set(x_142, 1, x_114); +lean_ctor_set(x_142, 2, x_115); +lean_ctor_set(x_142, 3, x_116); +lean_ctor_set_uint64(x_142, sizeof(void*)*4, x_117); +x_143 = lean_expr_update_let(x_142, x_119, x_122, x_140); +x_144 = lean_ctor_get(x_141, 0); +lean_inc(x_144); +x_145 = lean_ctor_get(x_141, 1); lean_inc(x_145); -lean_dec(x_137); -x_146 = lean_expr_update_let(x_3, x_129, x_132, x_136); -lean_inc(x_146); -x_147 = lean_array_uset(x_145, x_6, x_146); -x_148 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_148, 0, x_139); -lean_ctor_set(x_148, 1, x_147); -lean_ctor_set(x_134, 1, x_148); -lean_ctor_set(x_134, 0, x_146); -return x_134; -} -else -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; -lean_dec(x_3); -x_149 = lean_ctor_get(x_137, 1); -lean_inc(x_149); -lean_dec(x_137); -x_150 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_150, 0, x_123); -lean_ctor_set(x_150, 1, x_124); -lean_ctor_set(x_150, 2, x_125); -lean_ctor_set(x_150, 3, x_126); -lean_ctor_set_uint64(x_150, sizeof(void*)*4, x_127); -x_151 = lean_expr_update_let(x_150, x_129, x_132, x_136); -lean_inc(x_151); -x_152 = lean_array_uset(x_149, x_6, x_151); -x_153 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_153, 0, x_139); -lean_ctor_set(x_153, 1, x_152); -lean_ctor_set(x_134, 1, x_153); -lean_ctor_set(x_134, 0, x_151); -return x_134; -} -} -else -{ -lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; -x_154 = lean_ctor_get(x_134, 0); -x_155 = lean_ctor_get(x_134, 1); -lean_inc(x_155); -lean_inc(x_154); -lean_dec(x_134); -x_156 = lean_ctor_get(x_155, 0); -lean_inc(x_156); -lean_inc(x_3); -x_157 = lean_array_uset(x_156, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - x_158 = x_3; +if (lean_is_exclusive(x_141)) { + lean_ctor_release(x_141, 0); + lean_ctor_release(x_141, 1); + x_146 = x_141; } else { - lean_dec_ref(x_3); - x_158 = lean_box(0); + lean_dec_ref(x_141); + x_146 = lean_box(0); } -x_159 = lean_ctor_get(x_155, 1); -lean_inc(x_159); -lean_dec(x_155); -if (lean_is_scalar(x_158)) { - x_160 = lean_alloc_ctor(8, 4, 8); +x_147 = lean_array_uset(x_144, x_6, x_3); +lean_inc(x_143); +x_148 = lean_array_uset(x_145, x_6, x_143); +if (lean_is_scalar(x_146)) { + x_149 = lean_alloc_ctor(0, 2, 0); } else { - x_160 = x_158; + x_149 = x_146; } -lean_ctor_set(x_160, 0, x_123); -lean_ctor_set(x_160, 1, x_124); -lean_ctor_set(x_160, 2, x_125); -lean_ctor_set(x_160, 3, x_126); -lean_ctor_set_uint64(x_160, sizeof(void*)*4, x_127); -x_161 = lean_expr_update_let(x_160, x_129, x_132, x_154); -lean_inc(x_161); -x_162 = lean_array_uset(x_159, x_6, x_161); -x_163 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_163, 0, x_157); -lean_ctor_set(x_163, 1, x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_161); -lean_ctor_set(x_164, 1, x_163); -return x_164; +lean_ctor_set(x_149, 0, x_147); +lean_ctor_set(x_149, 1, x_148); +x_150 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_150, 0, x_143); +lean_ctor_set(x_150, 1, x_149); +return x_150; } } case 10: { -lean_object* x_165; lean_object* x_166; uint64_t x_167; lean_object* x_168; uint8_t x_169; -x_165 = lean_ctor_get(x_3, 0); +lean_object* x_151; lean_object* x_152; uint64_t x_153; lean_object* x_154; uint8_t x_155; +x_151 = lean_ctor_get(x_3, 0); +lean_inc(x_151); +x_152 = lean_ctor_get(x_3, 1); +lean_inc(x_152); +x_153 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); +lean_inc(x_152); +x_154 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_152, x_4); +x_155 = !lean_is_exclusive(x_154); +if (x_155 == 0) +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; lean_object* x_159; uint8_t x_160; +x_156 = lean_ctor_get(x_154, 0); +x_157 = lean_ctor_get(x_154, 1); +x_158 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_158, 0, x_151); +lean_ctor_set(x_158, 1, x_152); +lean_ctor_set_uint64(x_158, sizeof(void*)*2, x_153); +x_159 = lean_expr_update_mdata(x_158, x_156); +x_160 = !lean_is_exclusive(x_157); +if (x_160 == 0) +{ +lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_161 = lean_ctor_get(x_157, 0); +x_162 = lean_ctor_get(x_157, 1); +x_163 = lean_array_uset(x_161, x_6, x_3); +lean_inc(x_159); +x_164 = lean_array_uset(x_162, x_6, x_159); +lean_ctor_set(x_157, 1, x_164); +lean_ctor_set(x_157, 0, x_163); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +else +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_165 = lean_ctor_get(x_157, 0); +x_166 = lean_ctor_get(x_157, 1); +lean_inc(x_166); lean_inc(x_165); -x_166 = lean_ctor_get(x_3, 1); -lean_inc(x_166); -x_167 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); -lean_inc(x_166); -x_168 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_166, x_4); -x_169 = !lean_is_exclusive(x_168); -if (x_169 == 0) +lean_dec(x_157); +x_167 = lean_array_uset(x_165, x_6, x_3); +lean_inc(x_159); +x_168 = lean_array_uset(x_166, x_6, x_159); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_167); +lean_ctor_set(x_169, 1, x_168); +lean_ctor_set(x_154, 1, x_169); +lean_ctor_set(x_154, 0, x_159); +return x_154; +} +} +else { -lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; uint8_t x_174; -x_170 = lean_ctor_get(x_168, 0); -x_171 = lean_ctor_get(x_168, 1); -x_172 = lean_ctor_get(x_171, 0); -lean_inc(x_172); -lean_inc(x_3); -x_173 = lean_array_uset(x_172, x_6, x_3); -x_174 = !lean_is_exclusive(x_3); -if (x_174 == 0) -{ -lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; -x_175 = lean_ctor_get(x_3, 1); -lean_dec(x_175); -x_176 = lean_ctor_get(x_3, 0); -lean_dec(x_176); -x_177 = lean_ctor_get(x_171, 1); -lean_inc(x_177); -lean_dec(x_171); -x_178 = lean_expr_update_mdata(x_3, x_170); -lean_inc(x_178); -x_179 = lean_array_uset(x_177, x_6, x_178); +lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_170 = lean_ctor_get(x_154, 0); +x_171 = lean_ctor_get(x_154, 1); +lean_inc(x_171); +lean_inc(x_170); +lean_dec(x_154); +x_172 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_172, 0, x_151); +lean_ctor_set(x_172, 1, x_152); +lean_ctor_set_uint64(x_172, sizeof(void*)*2, x_153); +x_173 = lean_expr_update_mdata(x_172, x_170); +x_174 = lean_ctor_get(x_171, 0); +lean_inc(x_174); +x_175 = lean_ctor_get(x_171, 1); +lean_inc(x_175); +if (lean_is_exclusive(x_171)) { + lean_ctor_release(x_171, 0); + lean_ctor_release(x_171, 1); + x_176 = x_171; +} else { + lean_dec_ref(x_171); + x_176 = lean_box(0); +} +x_177 = lean_array_uset(x_174, x_6, x_3); +lean_inc(x_173); +x_178 = lean_array_uset(x_175, x_6, x_173); +if (lean_is_scalar(x_176)) { + x_179 = lean_alloc_ctor(0, 2, 0); +} else { + x_179 = x_176; +} +lean_ctor_set(x_179, 0, x_177); +lean_ctor_set(x_179, 1, x_178); x_180 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_180, 0, x_173); lean_ctor_set(x_180, 1, x_179); -lean_ctor_set(x_168, 1, x_180); -lean_ctor_set(x_168, 0, x_178); -return x_168; -} -else -{ -lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; -lean_dec(x_3); -x_181 = lean_ctor_get(x_171, 1); -lean_inc(x_181); -lean_dec(x_171); -x_182 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_182, 0, x_165); -lean_ctor_set(x_182, 1, x_166); -lean_ctor_set_uint64(x_182, sizeof(void*)*2, x_167); -x_183 = lean_expr_update_mdata(x_182, x_170); -lean_inc(x_183); -x_184 = lean_array_uset(x_181, x_6, x_183); -x_185 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_185, 0, x_173); -lean_ctor_set(x_185, 1, x_184); -lean_ctor_set(x_168, 1, x_185); -lean_ctor_set(x_168, 0, x_183); -return x_168; -} -} -else -{ -lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; -x_186 = lean_ctor_get(x_168, 0); -x_187 = lean_ctor_get(x_168, 1); -lean_inc(x_187); -lean_inc(x_186); -lean_dec(x_168); -x_188 = lean_ctor_get(x_187, 0); -lean_inc(x_188); -lean_inc(x_3); -x_189 = lean_array_uset(x_188, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_190 = x_3; -} else { - lean_dec_ref(x_3); - x_190 = lean_box(0); -} -x_191 = lean_ctor_get(x_187, 1); -lean_inc(x_191); -lean_dec(x_187); -if (lean_is_scalar(x_190)) { - x_192 = lean_alloc_ctor(10, 2, 8); -} else { - x_192 = x_190; -} -lean_ctor_set(x_192, 0, x_165); -lean_ctor_set(x_192, 1, x_166); -lean_ctor_set_uint64(x_192, sizeof(void*)*2, x_167); -x_193 = lean_expr_update_mdata(x_192, x_186); -lean_inc(x_193); -x_194 = lean_array_uset(x_191, x_6, x_193); -x_195 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_195, 0, x_189); -lean_ctor_set(x_195, 1, x_194); -x_196 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_196, 0, x_193); -lean_ctor_set(x_196, 1, x_195); -return x_196; +return x_180; } } case 11: { -lean_object* x_197; lean_object* x_198; lean_object* x_199; uint64_t x_200; lean_object* x_201; uint8_t x_202; -x_197 = lean_ctor_get(x_3, 0); +lean_object* x_181; lean_object* x_182; lean_object* x_183; uint64_t x_184; lean_object* x_185; uint8_t x_186; +x_181 = lean_ctor_get(x_3, 0); +lean_inc(x_181); +x_182 = lean_ctor_get(x_3, 1); +lean_inc(x_182); +x_183 = lean_ctor_get(x_3, 2); +lean_inc(x_183); +x_184 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_183); +x_185 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_183, x_4); +x_186 = !lean_is_exclusive(x_185); +if (x_186 == 0) +{ +lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; uint8_t x_191; +x_187 = lean_ctor_get(x_185, 0); +x_188 = lean_ctor_get(x_185, 1); +x_189 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_189, 0, x_181); +lean_ctor_set(x_189, 1, x_182); +lean_ctor_set(x_189, 2, x_183); +lean_ctor_set_uint64(x_189, sizeof(void*)*3, x_184); +x_190 = lean_expr_update_proj(x_189, x_187); +x_191 = !lean_is_exclusive(x_188); +if (x_191 == 0) +{ +lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; +x_192 = lean_ctor_get(x_188, 0); +x_193 = lean_ctor_get(x_188, 1); +x_194 = lean_array_uset(x_192, x_6, x_3); +lean_inc(x_190); +x_195 = lean_array_uset(x_193, x_6, x_190); +lean_ctor_set(x_188, 1, x_195); +lean_ctor_set(x_188, 0, x_194); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +else +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; +x_196 = lean_ctor_get(x_188, 0); +x_197 = lean_ctor_get(x_188, 1); lean_inc(x_197); -x_198 = lean_ctor_get(x_3, 1); -lean_inc(x_198); -x_199 = lean_ctor_get(x_3, 2); -lean_inc(x_199); -x_200 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_199); -x_201 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit___at_Lean_ParserCompiler_replaceParserTy___spec__1___rarg(x_1, x_2, x_199, x_4); -x_202 = !lean_is_exclusive(x_201); -if (x_202 == 0) +lean_inc(x_196); +lean_dec(x_188); +x_198 = lean_array_uset(x_196, x_6, x_3); +lean_inc(x_190); +x_199 = lean_array_uset(x_197, x_6, x_190); +x_200 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_200, 0, x_198); +lean_ctor_set(x_200, 1, x_199); +lean_ctor_set(x_185, 1, x_200); +lean_ctor_set(x_185, 0, x_190); +return x_185; +} +} +else { -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_201, 0); -x_204 = lean_ctor_get(x_201, 1); -x_205 = lean_ctor_get(x_204, 0); +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; lean_object* x_211; +x_201 = lean_ctor_get(x_185, 0); +x_202 = lean_ctor_get(x_185, 1); +lean_inc(x_202); +lean_inc(x_201); +lean_dec(x_185); +x_203 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_203, 0, x_181); +lean_ctor_set(x_203, 1, x_182); +lean_ctor_set(x_203, 2, x_183); +lean_ctor_set_uint64(x_203, sizeof(void*)*3, x_184); +x_204 = lean_expr_update_proj(x_203, x_201); +x_205 = lean_ctor_get(x_202, 0); lean_inc(x_205); -lean_inc(x_3); -x_206 = lean_array_uset(x_205, x_6, x_3); -x_207 = !lean_is_exclusive(x_3); -if (x_207 == 0) -{ -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; -x_208 = lean_ctor_get(x_3, 2); -lean_dec(x_208); -x_209 = lean_ctor_get(x_3, 1); -lean_dec(x_209); -x_210 = lean_ctor_get(x_3, 0); -lean_dec(x_210); -x_211 = lean_ctor_get(x_204, 1); -lean_inc(x_211); -lean_dec(x_204); -x_212 = lean_expr_update_proj(x_3, x_203); -lean_inc(x_212); -x_213 = lean_array_uset(x_211, x_6, x_212); -x_214 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_214, 0, x_206); -lean_ctor_set(x_214, 1, x_213); -lean_ctor_set(x_201, 1, x_214); -lean_ctor_set(x_201, 0, x_212); -return x_201; -} -else -{ -lean_object* x_215; lean_object* x_216; lean_object* x_217; lean_object* x_218; lean_object* x_219; -lean_dec(x_3); -x_215 = lean_ctor_get(x_204, 1); -lean_inc(x_215); -lean_dec(x_204); -x_216 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_216, 0, x_197); -lean_ctor_set(x_216, 1, x_198); -lean_ctor_set(x_216, 2, x_199); -lean_ctor_set_uint64(x_216, sizeof(void*)*3, x_200); -x_217 = lean_expr_update_proj(x_216, x_203); -lean_inc(x_217); -x_218 = lean_array_uset(x_215, x_6, x_217); -x_219 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_219, 0, x_206); -lean_ctor_set(x_219, 1, x_218); -lean_ctor_set(x_201, 1, x_219); -lean_ctor_set(x_201, 0, x_217); -return x_201; -} -} -else -{ -lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; -x_220 = lean_ctor_get(x_201, 0); -x_221 = lean_ctor_get(x_201, 1); -lean_inc(x_221); -lean_inc(x_220); -lean_dec(x_201); -x_222 = lean_ctor_get(x_221, 0); -lean_inc(x_222); -lean_inc(x_3); -x_223 = lean_array_uset(x_222, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_224 = x_3; +x_206 = lean_ctor_get(x_202, 1); +lean_inc(x_206); +if (lean_is_exclusive(x_202)) { + lean_ctor_release(x_202, 0); + lean_ctor_release(x_202, 1); + x_207 = x_202; } else { - lean_dec_ref(x_3); - x_224 = lean_box(0); + lean_dec_ref(x_202); + x_207 = lean_box(0); } -x_225 = lean_ctor_get(x_221, 1); -lean_inc(x_225); -lean_dec(x_221); -if (lean_is_scalar(x_224)) { - x_226 = lean_alloc_ctor(11, 3, 8); +x_208 = lean_array_uset(x_205, x_6, x_3); +lean_inc(x_204); +x_209 = lean_array_uset(x_206, x_6, x_204); +if (lean_is_scalar(x_207)) { + x_210 = lean_alloc_ctor(0, 2, 0); } else { - x_226 = x_224; + x_210 = x_207; } -lean_ctor_set(x_226, 0, x_197); -lean_ctor_set(x_226, 1, x_198); -lean_ctor_set(x_226, 2, x_199); -lean_ctor_set_uint64(x_226, sizeof(void*)*3, x_200); -x_227 = lean_expr_update_proj(x_226, x_220); -lean_inc(x_227); -x_228 = lean_array_uset(x_225, x_6, x_227); -x_229 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_229, 0, x_223); -lean_ctor_set(x_229, 1, x_228); -x_230 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_230, 0, x_227); -lean_ctor_set(x_230, 1, x_229); -return x_230; +lean_ctor_set(x_210, 0, x_208); +lean_ctor_set(x_210, 1, x_209); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_204); +lean_ctor_set(x_211, 1, x_210); +return x_211; } } default: { -lean_object* x_231; -x_231 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_231, 0, x_3); -lean_ctor_set(x_231, 1, x_4); -return x_231; +lean_object* x_212; +x_212 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_212, 0, x_3); +lean_ctor_set(x_212, 1, x_4); +return x_212; } } } diff --git a/stage0/stdlib/Lean/Util/ReplaceExpr.c b/stage0/stdlib/Lean/Util/ReplaceExpr.c index 7c926dbe25..db4e9558d8 100644 --- a/stage0/stdlib/Lean/Util/ReplaceExpr.c +++ b/stage0/stdlib/Lean/Util/ReplaceExpr.c @@ -23,6 +23,8 @@ lean_object* l_Lean_Expr_ReplaceImpl_cache___boxed(lean_object*, lean_object*, l lean_object* l_Lean_Expr_ReplaceImpl_initCache___closed__2; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit_match__2(lean_object*); lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafe(lean_object*, lean_object*); +lean_object* l_Lean_Expr_ReplaceImpl_cache_match__1___rarg(lean_object*, lean_object*); +lean_object* l_Lean_Expr_ReplaceImpl_cache_match__1(lean_object*); size_t l_Lean_Expr_ReplaceImpl_cacheSize; lean_object* l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit_match__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_expr_update_let(lean_object*, lean_object*, lean_object*, lean_object*); @@ -52,26 +54,67 @@ x_1 = 8192; return x_1; } } +lean_object* l_Lean_Expr_ReplaceImpl_cache_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_Expr_ReplaceImpl_cache_match__1(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = lean_alloc_closure((void*)(l_Lean_Expr_ReplaceImpl_cache_match__1___rarg), 2, 0); +return x_2; +} +} lean_object* l_Lean_Expr_ReplaceImpl_cache(size_t x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: { -lean_object* x_5; lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; -x_5 = lean_ctor_get(x_4, 0); -lean_inc(x_5); -x_6 = lean_array_uset(x_5, x_1, x_2); +uint8_t x_5; +x_5 = !lean_is_exclusive(x_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; +x_6 = lean_ctor_get(x_4, 0); x_7 = lean_ctor_get(x_4, 1); -lean_inc(x_7); -lean_dec(x_4); +x_8 = lean_array_uset(x_6, x_1, x_2); lean_inc(x_3); -x_8 = lean_array_uset(x_7, x_1, x_3); -x_9 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_9, 0, x_6); -lean_ctor_set(x_9, 1, x_8); +x_9 = lean_array_uset(x_7, x_1, x_3); +lean_ctor_set(x_4, 1, x_9); +lean_ctor_set(x_4, 0, x_8); x_10 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_10, 0, x_3); -lean_ctor_set(x_10, 1, x_9); +lean_ctor_set(x_10, 1, x_4); return x_10; } +else +{ +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; +x_11 = lean_ctor_get(x_4, 0); +x_12 = lean_ctor_get(x_4, 1); +lean_inc(x_12); +lean_inc(x_11); +lean_dec(x_4); +x_13 = lean_array_uset(x_11, x_1, x_2); +lean_inc(x_3); +x_14 = lean_array_uset(x_12, x_1, x_3); +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(0, 2, 0); +lean_ctor_set(x_16, 0, x_3); +lean_ctor_set(x_16, 1, x_15); +return x_16; +} +} } lean_object* l_Lean_Expr_ReplaceImpl_cache___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4) { _start: @@ -274,6 +317,7 @@ x_6 = x_2 == 0 ? x_5 : x_5 % x_2; x_7 = lean_ctor_get(x_4, 0); lean_inc(x_7); x_8 = lean_array_uget(x_7, x_6); +lean_dec(x_7); x_9 = lean_ptr_addr(x_8); lean_dec(x_8); x_10 = x_9 == x_5; @@ -285,7 +329,6 @@ lean_inc(x_3); x_11 = lean_apply_1(x_1, x_3); if (lean_obj_tag(x_11) == 0) { -lean_dec(x_7); switch (lean_obj_tag(x_3)) { case 5: { @@ -311,746 +354,684 @@ if (x_19 == 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_18, 0); x_21 = lean_ctor_get(x_18, 1); -x_22 = lean_ctor_get(x_21, 0); -lean_inc(x_22); -lean_inc(x_3); -x_23 = lean_array_uset(x_22, x_6, x_3); -x_24 = !lean_is_exclusive(x_3); +x_22 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_22, 0, x_12); +lean_ctor_set(x_22, 1, x_13); +lean_ctor_set_uint64(x_22, sizeof(void*)*2, x_14); +x_23 = lean_expr_update_app(x_22, x_16, x_20); +x_24 = !lean_is_exclusive(x_21); if (x_24 == 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_3, 1); -lean_dec(x_25); -x_26 = lean_ctor_get(x_3, 0); -lean_dec(x_26); -x_27 = lean_ctor_get(x_21, 1); -lean_inc(x_27); -lean_dec(x_21); -x_28 = lean_expr_update_app(x_3, x_16, x_20); -lean_inc(x_28); -x_29 = lean_array_uset(x_27, x_6, x_28); -x_30 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_30, 0, x_23); -lean_ctor_set(x_30, 1, x_29); -lean_ctor_set(x_18, 1, x_30); -lean_ctor_set(x_18, 0, x_28); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; +x_25 = lean_ctor_get(x_21, 0); +x_26 = lean_ctor_get(x_21, 1); +x_27 = lean_array_uset(x_25, x_6, x_3); +lean_inc(x_23); +x_28 = lean_array_uset(x_26, x_6, x_23); +lean_ctor_set(x_21, 1, x_28); +lean_ctor_set(x_21, 0, x_27); +lean_ctor_set(x_18, 0, x_23); return x_18; } else { -lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; -lean_dec(x_3); -x_31 = lean_ctor_get(x_21, 1); -lean_inc(x_31); +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_29 = lean_ctor_get(x_21, 0); +x_30 = lean_ctor_get(x_21, 1); +lean_inc(x_30); +lean_inc(x_29); lean_dec(x_21); -x_32 = lean_alloc_ctor(5, 2, 8); -lean_ctor_set(x_32, 0, x_12); -lean_ctor_set(x_32, 1, x_13); -lean_ctor_set_uint64(x_32, sizeof(void*)*2, x_14); -x_33 = lean_expr_update_app(x_32, x_16, x_20); -lean_inc(x_33); -x_34 = lean_array_uset(x_31, x_6, x_33); -x_35 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_35, 0, x_23); -lean_ctor_set(x_35, 1, x_34); -lean_ctor_set(x_18, 1, x_35); -lean_ctor_set(x_18, 0, x_33); +x_31 = lean_array_uset(x_29, x_6, x_3); +lean_inc(x_23); +x_32 = lean_array_uset(x_30, x_6, x_23); +x_33 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +lean_ctor_set(x_18, 1, x_33); +lean_ctor_set(x_18, 0, x_23); return x_18; } } 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; -x_36 = lean_ctor_get(x_18, 0); -x_37 = lean_ctor_get(x_18, 1); -lean_inc(x_37); -lean_inc(x_36); +lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_34 = lean_ctor_get(x_18, 0); +x_35 = lean_ctor_get(x_18, 1); +lean_inc(x_35); +lean_inc(x_34); lean_dec(x_18); -x_38 = lean_ctor_get(x_37, 0); +x_36 = lean_alloc_ctor(5, 2, 8); +lean_ctor_set(x_36, 0, x_12); +lean_ctor_set(x_36, 1, x_13); +lean_ctor_set_uint64(x_36, sizeof(void*)*2, x_14); +x_37 = lean_expr_update_app(x_36, x_16, x_34); +x_38 = lean_ctor_get(x_35, 0); lean_inc(x_38); -lean_inc(x_3); -x_39 = lean_array_uset(x_38, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_40 = x_3; +x_39 = lean_ctor_get(x_35, 1); +lean_inc(x_39); +if (lean_is_exclusive(x_35)) { + lean_ctor_release(x_35, 0); + lean_ctor_release(x_35, 1); + x_40 = x_35; } else { - lean_dec_ref(x_3); + lean_dec_ref(x_35); x_40 = lean_box(0); } -x_41 = lean_ctor_get(x_37, 1); -lean_inc(x_41); -lean_dec(x_37); +x_41 = lean_array_uset(x_38, x_6, x_3); +lean_inc(x_37); +x_42 = lean_array_uset(x_39, x_6, x_37); if (lean_is_scalar(x_40)) { - x_42 = lean_alloc_ctor(5, 2, 8); + x_43 = lean_alloc_ctor(0, 2, 0); } else { - x_42 = x_40; + x_43 = x_40; } -lean_ctor_set(x_42, 0, x_12); -lean_ctor_set(x_42, 1, x_13); -lean_ctor_set_uint64(x_42, sizeof(void*)*2, x_14); -x_43 = lean_expr_update_app(x_42, x_16, x_36); -lean_inc(x_43); -x_44 = lean_array_uset(x_41, x_6, x_43); -x_45 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_45, 0, x_39); -lean_ctor_set(x_45, 1, x_44); -x_46 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_46, 0, x_43); -lean_ctor_set(x_46, 1, x_45); -return x_46; +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_37); +lean_ctor_set(x_44, 1, x_43); +return x_44; } } case 6: { -lean_object* x_47; lean_object* x_48; lean_object* x_49; uint64_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; -x_47 = lean_ctor_get(x_3, 0); +lean_object* x_45; lean_object* x_46; lean_object* x_47; uint64_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; +x_45 = lean_ctor_get(x_3, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_3, 1); +lean_inc(x_46); +x_47 = lean_ctor_get(x_3, 2); lean_inc(x_47); -x_48 = lean_ctor_get(x_3, 1); -lean_inc(x_48); -x_49 = lean_ctor_get(x_3, 2); -lean_inc(x_49); -x_50 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_48); +x_48 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_46); lean_inc(x_1); -x_51 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_48, x_4); -x_52 = lean_ctor_get(x_51, 0); -lean_inc(x_52); -x_53 = lean_ctor_get(x_51, 1); -lean_inc(x_53); -lean_dec(x_51); -lean_inc(x_49); -x_54 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_49, x_53); -x_55 = !lean_is_exclusive(x_54); -if (x_55 == 0) +x_49 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_46, x_4); +x_50 = lean_ctor_get(x_49, 0); +lean_inc(x_50); +x_51 = lean_ctor_get(x_49, 1); +lean_inc(x_51); +lean_dec(x_49); +lean_inc(x_47); +x_52 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_47, x_51); +x_53 = !lean_is_exclusive(x_52); +if (x_53 == 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_54, 0); -x_57 = lean_ctor_get(x_54, 1); -x_58 = lean_ctor_get(x_57, 0); +lean_object* x_54; lean_object* x_55; lean_object* x_56; uint8_t x_57; lean_object* x_58; uint8_t x_59; +x_54 = lean_ctor_get(x_52, 0); +x_55 = lean_ctor_get(x_52, 1); +x_56 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_56, 0, x_45); +lean_ctor_set(x_56, 1, x_46); +lean_ctor_set(x_56, 2, x_47); +lean_ctor_set_uint64(x_56, sizeof(void*)*3, x_48); +x_57 = (uint8_t)((x_48 << 24) >> 61); +x_58 = lean_expr_update_lambda(x_56, x_57, x_50, x_54); +x_59 = !lean_is_exclusive(x_55); +if (x_59 == 0) +{ +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_60 = lean_ctor_get(x_55, 0); +x_61 = lean_ctor_get(x_55, 1); +x_62 = lean_array_uset(x_60, x_6, x_3); lean_inc(x_58); -lean_inc(x_3); -x_59 = lean_array_uset(x_58, x_6, x_3); -x_60 = !lean_is_exclusive(x_3); -if (x_60 == 0) +x_63 = lean_array_uset(x_61, x_6, x_58); +lean_ctor_set(x_55, 1, x_63); +lean_ctor_set(x_55, 0, x_62); +lean_ctor_set(x_52, 0, x_58); +return x_52; +} +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; lean_object* x_67; lean_object* x_68; -x_61 = lean_ctor_get(x_3, 2); -lean_dec(x_61); -x_62 = lean_ctor_get(x_3, 1); -lean_dec(x_62); -x_63 = lean_ctor_get(x_3, 0); -lean_dec(x_63); -x_64 = lean_ctor_get(x_57, 1); +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_64 = lean_ctor_get(x_55, 0); +x_65 = lean_ctor_get(x_55, 1); +lean_inc(x_65); lean_inc(x_64); -lean_dec(x_57); -x_65 = (uint8_t)((x_50 << 24) >> 61); -x_66 = lean_expr_update_lambda(x_3, x_65, x_52, x_56); -lean_inc(x_66); -x_67 = lean_array_uset(x_64, x_6, x_66); +lean_dec(x_55); +x_66 = lean_array_uset(x_64, x_6, x_3); +lean_inc(x_58); +x_67 = lean_array_uset(x_65, x_6, x_58); x_68 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_68, 0, x_59); +lean_ctor_set(x_68, 0, x_66); lean_ctor_set(x_68, 1, x_67); -lean_ctor_set(x_54, 1, x_68); -lean_ctor_set(x_54, 0, x_66); -return x_54; +lean_ctor_set(x_52, 1, x_68); +lean_ctor_set(x_52, 0, x_58); +return x_52; +} } else { -lean_object* x_69; lean_object* x_70; uint8_t x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; -lean_dec(x_3); -x_69 = lean_ctor_get(x_57, 1); +lean_object* x_69; lean_object* x_70; lean_object* x_71; uint8_t x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_69 = lean_ctor_get(x_52, 0); +x_70 = lean_ctor_get(x_52, 1); +lean_inc(x_70); lean_inc(x_69); -lean_dec(x_57); -x_70 = lean_alloc_ctor(6, 3, 8); -lean_ctor_set(x_70, 0, x_47); -lean_ctor_set(x_70, 1, x_48); -lean_ctor_set(x_70, 2, x_49); -lean_ctor_set_uint64(x_70, sizeof(void*)*3, x_50); -x_71 = (uint8_t)((x_50 << 24) >> 61); -x_72 = lean_expr_update_lambda(x_70, x_71, x_52, x_56); -lean_inc(x_72); -x_73 = lean_array_uset(x_69, x_6, x_72); -x_74 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_74, 0, x_59); -lean_ctor_set(x_74, 1, x_73); -lean_ctor_set(x_54, 1, x_74); -lean_ctor_set(x_54, 0, x_72); -return x_54; -} -} -else -{ -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; lean_object* x_85; lean_object* x_86; -x_75 = lean_ctor_get(x_54, 0); -x_76 = lean_ctor_get(x_54, 1); -lean_inc(x_76); +lean_dec(x_52); +x_71 = lean_alloc_ctor(6, 3, 8); +lean_ctor_set(x_71, 0, x_45); +lean_ctor_set(x_71, 1, x_46); +lean_ctor_set(x_71, 2, x_47); +lean_ctor_set_uint64(x_71, sizeof(void*)*3, x_48); +x_72 = (uint8_t)((x_48 << 24) >> 61); +x_73 = lean_expr_update_lambda(x_71, x_72, x_50, x_69); +x_74 = lean_ctor_get(x_70, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_70, 1); lean_inc(x_75); -lean_dec(x_54); -x_77 = lean_ctor_get(x_76, 0); -lean_inc(x_77); -lean_inc(x_3); -x_78 = lean_array_uset(x_77, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_79 = x_3; +if (lean_is_exclusive(x_70)) { + lean_ctor_release(x_70, 0); + lean_ctor_release(x_70, 1); + x_76 = x_70; } else { - lean_dec_ref(x_3); - x_79 = lean_box(0); + lean_dec_ref(x_70); + x_76 = lean_box(0); } -x_80 = lean_ctor_get(x_76, 1); -lean_inc(x_80); -lean_dec(x_76); -if (lean_is_scalar(x_79)) { - x_81 = lean_alloc_ctor(6, 3, 8); +x_77 = lean_array_uset(x_74, x_6, x_3); +lean_inc(x_73); +x_78 = lean_array_uset(x_75, x_6, x_73); +if (lean_is_scalar(x_76)) { + x_79 = lean_alloc_ctor(0, 2, 0); } else { - x_81 = x_79; + x_79 = x_76; } -lean_ctor_set(x_81, 0, x_47); -lean_ctor_set(x_81, 1, x_48); -lean_ctor_set(x_81, 2, x_49); -lean_ctor_set_uint64(x_81, sizeof(void*)*3, x_50); -x_82 = (uint8_t)((x_50 << 24) >> 61); -x_83 = lean_expr_update_lambda(x_81, x_82, x_52, x_75); -lean_inc(x_83); -x_84 = lean_array_uset(x_80, x_6, x_83); -x_85 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_85, 0, x_78); -lean_ctor_set(x_85, 1, x_84); -x_86 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_86, 0, x_83); -lean_ctor_set(x_86, 1, x_85); -return x_86; +lean_ctor_set(x_79, 0, x_77); +lean_ctor_set(x_79, 1, x_78); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_73); +lean_ctor_set(x_80, 1, x_79); +return x_80; } } case 7: { -lean_object* x_87; lean_object* x_88; lean_object* x_89; uint64_t 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_3, 0); -lean_inc(x_87); -x_88 = lean_ctor_get(x_3, 1); -lean_inc(x_88); -x_89 = lean_ctor_get(x_3, 2); -lean_inc(x_89); -x_90 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_88); +lean_object* x_81; lean_object* x_82; lean_object* x_83; uint64_t x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; uint8_t x_89; +x_81 = lean_ctor_get(x_3, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_3, 1); +lean_inc(x_82); +x_83 = lean_ctor_get(x_3, 2); +lean_inc(x_83); +x_84 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_82); lean_inc(x_1); -x_91 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_88, x_4); -x_92 = lean_ctor_get(x_91, 0); -lean_inc(x_92); -x_93 = lean_ctor_get(x_91, 1); -lean_inc(x_93); -lean_dec(x_91); -lean_inc(x_89); -x_94 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_89, x_93); -x_95 = !lean_is_exclusive(x_94); +x_85 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_82, x_4); +x_86 = lean_ctor_get(x_85, 0); +lean_inc(x_86); +x_87 = lean_ctor_get(x_85, 1); +lean_inc(x_87); +lean_dec(x_85); +lean_inc(x_83); +x_88 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_83, x_87); +x_89 = !lean_is_exclusive(x_88); +if (x_89 == 0) +{ +lean_object* x_90; lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; uint8_t x_95; +x_90 = lean_ctor_get(x_88, 0); +x_91 = lean_ctor_get(x_88, 1); +x_92 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_92, 0, x_81); +lean_ctor_set(x_92, 1, x_82); +lean_ctor_set(x_92, 2, x_83); +lean_ctor_set_uint64(x_92, sizeof(void*)*3, x_84); +x_93 = (uint8_t)((x_84 << 24) >> 61); +x_94 = lean_expr_update_forall(x_92, x_93, x_86, x_90); +x_95 = !lean_is_exclusive(x_91); 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_94, 0); -x_97 = lean_ctor_get(x_94, 1); -x_98 = lean_ctor_get(x_97, 0); -lean_inc(x_98); -lean_inc(x_3); -x_99 = lean_array_uset(x_98, x_6, x_3); -x_100 = !lean_is_exclusive(x_3); -if (x_100 == 0) +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; +x_96 = lean_ctor_get(x_91, 0); +x_97 = lean_ctor_get(x_91, 1); +x_98 = lean_array_uset(x_96, x_6, x_3); +lean_inc(x_94); +x_99 = lean_array_uset(x_97, x_6, x_94); +lean_ctor_set(x_91, 1, x_99); +lean_ctor_set(x_91, 0, x_98); +lean_ctor_set(x_88, 0, x_94); +return x_88; +} +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; lean_object* x_107; lean_object* x_108; -x_101 = lean_ctor_get(x_3, 2); -lean_dec(x_101); -x_102 = lean_ctor_get(x_3, 1); -lean_dec(x_102); -x_103 = lean_ctor_get(x_3, 0); -lean_dec(x_103); -x_104 = lean_ctor_get(x_97, 1); -lean_inc(x_104); -lean_dec(x_97); -x_105 = (uint8_t)((x_90 << 24) >> 61); -x_106 = lean_expr_update_forall(x_3, x_105, x_92, x_96); +lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; +x_100 = lean_ctor_get(x_91, 0); +x_101 = lean_ctor_get(x_91, 1); +lean_inc(x_101); +lean_inc(x_100); +lean_dec(x_91); +x_102 = lean_array_uset(x_100, x_6, x_3); +lean_inc(x_94); +x_103 = lean_array_uset(x_101, x_6, x_94); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_102); +lean_ctor_set(x_104, 1, x_103); +lean_ctor_set(x_88, 1, x_104); +lean_ctor_set(x_88, 0, x_94); +return x_88; +} +} +else +{ +lean_object* x_105; lean_object* x_106; lean_object* x_107; uint8_t 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_105 = lean_ctor_get(x_88, 0); +x_106 = lean_ctor_get(x_88, 1); lean_inc(x_106); -x_107 = lean_array_uset(x_104, x_6, x_106); -x_108 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_108, 0, x_99); -lean_ctor_set(x_108, 1, x_107); -lean_ctor_set(x_94, 1, x_108); -lean_ctor_set(x_94, 0, x_106); -return x_94; +lean_inc(x_105); +lean_dec(x_88); +x_107 = lean_alloc_ctor(7, 3, 8); +lean_ctor_set(x_107, 0, x_81); +lean_ctor_set(x_107, 1, x_82); +lean_ctor_set(x_107, 2, x_83); +lean_ctor_set_uint64(x_107, sizeof(void*)*3, x_84); +x_108 = (uint8_t)((x_84 << 24) >> 61); +x_109 = lean_expr_update_forall(x_107, x_108, x_86, x_105); +x_110 = lean_ctor_get(x_106, 0); +lean_inc(x_110); +x_111 = lean_ctor_get(x_106, 1); +lean_inc(x_111); +if (lean_is_exclusive(x_106)) { + lean_ctor_release(x_106, 0); + lean_ctor_release(x_106, 1); + x_112 = x_106; +} else { + lean_dec_ref(x_106); + x_112 = lean_box(0); } -else -{ -lean_object* x_109; lean_object* x_110; uint8_t x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; -lean_dec(x_3); -x_109 = lean_ctor_get(x_97, 1); +x_113 = lean_array_uset(x_110, x_6, x_3); lean_inc(x_109); -lean_dec(x_97); -x_110 = lean_alloc_ctor(7, 3, 8); -lean_ctor_set(x_110, 0, x_87); -lean_ctor_set(x_110, 1, x_88); -lean_ctor_set(x_110, 2, x_89); -lean_ctor_set_uint64(x_110, sizeof(void*)*3, x_90); -x_111 = (uint8_t)((x_90 << 24) >> 61); -x_112 = lean_expr_update_forall(x_110, x_111, x_92, x_96); -lean_inc(x_112); -x_113 = lean_array_uset(x_109, x_6, x_112); -x_114 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_114, 0, x_99); -lean_ctor_set(x_114, 1, x_113); -lean_ctor_set(x_94, 1, x_114); -lean_ctor_set(x_94, 0, x_112); -return x_94; -} -} -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; uint8_t x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; -x_115 = lean_ctor_get(x_94, 0); -x_116 = lean_ctor_get(x_94, 1); -lean_inc(x_116); -lean_inc(x_115); -lean_dec(x_94); -x_117 = lean_ctor_get(x_116, 0); -lean_inc(x_117); -lean_inc(x_3); -x_118 = lean_array_uset(x_117, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_119 = x_3; +x_114 = lean_array_uset(x_111, x_6, x_109); +if (lean_is_scalar(x_112)) { + x_115 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_3); - x_119 = lean_box(0); + x_115 = x_112; } -x_120 = lean_ctor_get(x_116, 1); -lean_inc(x_120); -lean_dec(x_116); -if (lean_is_scalar(x_119)) { - x_121 = lean_alloc_ctor(7, 3, 8); -} else { - x_121 = x_119; -} -lean_ctor_set(x_121, 0, x_87); -lean_ctor_set(x_121, 1, x_88); -lean_ctor_set(x_121, 2, x_89); -lean_ctor_set_uint64(x_121, sizeof(void*)*3, x_90); -x_122 = (uint8_t)((x_90 << 24) >> 61); -x_123 = lean_expr_update_forall(x_121, x_122, x_92, x_115); -lean_inc(x_123); -x_124 = lean_array_uset(x_120, x_6, x_123); -x_125 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_125, 0, x_118); -lean_ctor_set(x_125, 1, x_124); -x_126 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_126, 0, x_123); -lean_ctor_set(x_126, 1, x_125); -return x_126; +lean_ctor_set(x_115, 0, x_113); +lean_ctor_set(x_115, 1, x_114); +x_116 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_116, 0, x_109); +lean_ctor_set(x_116, 1, x_115); +return x_116; } } case 8: { -lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; uint64_t 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; uint8_t x_139; -x_127 = lean_ctor_get(x_3, 0); +lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; uint64_t 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; uint8_t x_129; +x_117 = lean_ctor_get(x_3, 0); +lean_inc(x_117); +x_118 = lean_ctor_get(x_3, 1); +lean_inc(x_118); +x_119 = lean_ctor_get(x_3, 2); +lean_inc(x_119); +x_120 = lean_ctor_get(x_3, 3); +lean_inc(x_120); +x_121 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); +lean_inc(x_118); +lean_inc(x_1); +x_122 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_118, x_4); +x_123 = lean_ctor_get(x_122, 0); +lean_inc(x_123); +x_124 = lean_ctor_get(x_122, 1); +lean_inc(x_124); +lean_dec(x_122); +lean_inc(x_119); +lean_inc(x_1); +x_125 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_119, x_124); +x_126 = lean_ctor_get(x_125, 0); +lean_inc(x_126); +x_127 = lean_ctor_get(x_125, 1); lean_inc(x_127); -x_128 = lean_ctor_get(x_3, 1); -lean_inc(x_128); -x_129 = lean_ctor_get(x_3, 2); -lean_inc(x_129); -x_130 = lean_ctor_get(x_3, 3); -lean_inc(x_130); -x_131 = lean_ctor_get_uint64(x_3, sizeof(void*)*4); -lean_inc(x_128); -lean_inc(x_1); -x_132 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_128, x_4); -x_133 = lean_ctor_get(x_132, 0); +lean_dec(x_125); +lean_inc(x_120); +x_128 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_120, x_127); +x_129 = !lean_is_exclusive(x_128); +if (x_129 == 0) +{ +lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; uint8_t x_134; +x_130 = lean_ctor_get(x_128, 0); +x_131 = lean_ctor_get(x_128, 1); +x_132 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_132, 0, x_117); +lean_ctor_set(x_132, 1, x_118); +lean_ctor_set(x_132, 2, x_119); +lean_ctor_set(x_132, 3, x_120); +lean_ctor_set_uint64(x_132, sizeof(void*)*4, x_121); +x_133 = lean_expr_update_let(x_132, x_123, x_126, x_130); +x_134 = !lean_is_exclusive(x_131); +if (x_134 == 0) +{ +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_135 = lean_ctor_get(x_131, 0); +x_136 = lean_ctor_get(x_131, 1); +x_137 = lean_array_uset(x_135, x_6, x_3); lean_inc(x_133); -x_134 = lean_ctor_get(x_132, 1); -lean_inc(x_134); -lean_dec(x_132); -lean_inc(x_129); -lean_inc(x_1); -x_135 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_129, x_134); -x_136 = lean_ctor_get(x_135, 0); -lean_inc(x_136); -x_137 = lean_ctor_get(x_135, 1); -lean_inc(x_137); -lean_dec(x_135); -lean_inc(x_130); -x_138 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_130, x_137); -x_139 = !lean_is_exclusive(x_138); -if (x_139 == 0) +x_138 = lean_array_uset(x_136, x_6, x_133); +lean_ctor_set(x_131, 1, x_138); +lean_ctor_set(x_131, 0, x_137); +lean_ctor_set(x_128, 0, x_133); +return x_128; +} +else { -lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; uint8_t x_144; -x_140 = lean_ctor_get(x_138, 0); -x_141 = lean_ctor_get(x_138, 1); -x_142 = lean_ctor_get(x_141, 0); -lean_inc(x_142); -lean_inc(x_3); -x_143 = lean_array_uset(x_142, x_6, x_3); -x_144 = !lean_is_exclusive(x_3); -if (x_144 == 0) +lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; +x_139 = lean_ctor_get(x_131, 0); +x_140 = lean_ctor_get(x_131, 1); +lean_inc(x_140); +lean_inc(x_139); +lean_dec(x_131); +x_141 = lean_array_uset(x_139, x_6, x_3); +lean_inc(x_133); +x_142 = lean_array_uset(x_140, x_6, x_133); +x_143 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_143, 0, x_141); +lean_ctor_set(x_143, 1, x_142); +lean_ctor_set(x_128, 1, x_143); +lean_ctor_set(x_128, 0, x_133); +return x_128; +} +} +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; lean_object* x_152; -x_145 = lean_ctor_get(x_3, 3); -lean_dec(x_145); -x_146 = lean_ctor_get(x_3, 2); -lean_dec(x_146); -x_147 = lean_ctor_get(x_3, 1); -lean_dec(x_147); -x_148 = lean_ctor_get(x_3, 0); -lean_dec(x_148); -x_149 = lean_ctor_get(x_141, 1); +lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_144 = lean_ctor_get(x_128, 0); +x_145 = lean_ctor_get(x_128, 1); +lean_inc(x_145); +lean_inc(x_144); +lean_dec(x_128); +x_146 = lean_alloc_ctor(8, 4, 8); +lean_ctor_set(x_146, 0, x_117); +lean_ctor_set(x_146, 1, x_118); +lean_ctor_set(x_146, 2, x_119); +lean_ctor_set(x_146, 3, x_120); +lean_ctor_set_uint64(x_146, sizeof(void*)*4, x_121); +x_147 = lean_expr_update_let(x_146, x_123, x_126, x_144); +x_148 = lean_ctor_get(x_145, 0); +lean_inc(x_148); +x_149 = lean_ctor_get(x_145, 1); lean_inc(x_149); -lean_dec(x_141); -x_150 = lean_expr_update_let(x_3, x_133, x_136, x_140); -lean_inc(x_150); -x_151 = lean_array_uset(x_149, x_6, x_150); -x_152 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_152, 0, x_143); -lean_ctor_set(x_152, 1, x_151); -lean_ctor_set(x_138, 1, x_152); -lean_ctor_set(x_138, 0, x_150); -return x_138; -} -else -{ -lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; -lean_dec(x_3); -x_153 = lean_ctor_get(x_141, 1); -lean_inc(x_153); -lean_dec(x_141); -x_154 = lean_alloc_ctor(8, 4, 8); -lean_ctor_set(x_154, 0, x_127); -lean_ctor_set(x_154, 1, x_128); -lean_ctor_set(x_154, 2, x_129); -lean_ctor_set(x_154, 3, x_130); -lean_ctor_set_uint64(x_154, sizeof(void*)*4, x_131); -x_155 = lean_expr_update_let(x_154, x_133, x_136, x_140); -lean_inc(x_155); -x_156 = lean_array_uset(x_153, x_6, x_155); -x_157 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_157, 0, x_143); -lean_ctor_set(x_157, 1, x_156); -lean_ctor_set(x_138, 1, x_157); -lean_ctor_set(x_138, 0, x_155); -return x_138; -} -} -else -{ -lean_object* x_158; lean_object* x_159; lean_object* x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; -x_158 = lean_ctor_get(x_138, 0); -x_159 = lean_ctor_get(x_138, 1); -lean_inc(x_159); -lean_inc(x_158); -lean_dec(x_138); -x_160 = lean_ctor_get(x_159, 0); -lean_inc(x_160); -lean_inc(x_3); -x_161 = lean_array_uset(x_160, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - x_162 = x_3; +if (lean_is_exclusive(x_145)) { + lean_ctor_release(x_145, 0); + lean_ctor_release(x_145, 1); + x_150 = x_145; } else { - lean_dec_ref(x_3); - x_162 = lean_box(0); + lean_dec_ref(x_145); + x_150 = lean_box(0); } -x_163 = lean_ctor_get(x_159, 1); -lean_inc(x_163); -lean_dec(x_159); -if (lean_is_scalar(x_162)) { - x_164 = lean_alloc_ctor(8, 4, 8); +x_151 = lean_array_uset(x_148, x_6, x_3); +lean_inc(x_147); +x_152 = lean_array_uset(x_149, x_6, x_147); +if (lean_is_scalar(x_150)) { + x_153 = lean_alloc_ctor(0, 2, 0); } else { - x_164 = x_162; + x_153 = x_150; } -lean_ctor_set(x_164, 0, x_127); -lean_ctor_set(x_164, 1, x_128); -lean_ctor_set(x_164, 2, x_129); -lean_ctor_set(x_164, 3, x_130); -lean_ctor_set_uint64(x_164, sizeof(void*)*4, x_131); -x_165 = lean_expr_update_let(x_164, x_133, x_136, x_158); -lean_inc(x_165); -x_166 = lean_array_uset(x_163, x_6, x_165); -x_167 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_167, 0, x_161); -lean_ctor_set(x_167, 1, x_166); -x_168 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_168, 0, x_165); -lean_ctor_set(x_168, 1, x_167); -return x_168; +lean_ctor_set(x_153, 0, x_151); +lean_ctor_set(x_153, 1, x_152); +x_154 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_154, 0, x_147); +lean_ctor_set(x_154, 1, x_153); +return x_154; } } case 10: { -lean_object* x_169; lean_object* x_170; uint64_t x_171; lean_object* x_172; uint8_t x_173; -x_169 = lean_ctor_get(x_3, 0); +lean_object* x_155; lean_object* x_156; uint64_t x_157; lean_object* x_158; uint8_t x_159; +x_155 = lean_ctor_get(x_3, 0); +lean_inc(x_155); +x_156 = lean_ctor_get(x_3, 1); +lean_inc(x_156); +x_157 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); +lean_inc(x_156); +x_158 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_156, x_4); +x_159 = !lean_is_exclusive(x_158); +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_158, 0); +x_161 = lean_ctor_get(x_158, 1); +x_162 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_162, 0, x_155); +lean_ctor_set(x_162, 1, x_156); +lean_ctor_set_uint64(x_162, sizeof(void*)*2, x_157); +x_163 = lean_expr_update_mdata(x_162, x_160); +x_164 = !lean_is_exclusive(x_161); +if (x_164 == 0) +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; +x_165 = lean_ctor_get(x_161, 0); +x_166 = lean_ctor_get(x_161, 1); +x_167 = lean_array_uset(x_165, x_6, x_3); +lean_inc(x_163); +x_168 = lean_array_uset(x_166, x_6, x_163); +lean_ctor_set(x_161, 1, x_168); +lean_ctor_set(x_161, 0, x_167); +lean_ctor_set(x_158, 0, x_163); +return x_158; +} +else +{ +lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; +x_169 = lean_ctor_get(x_161, 0); +x_170 = lean_ctor_get(x_161, 1); +lean_inc(x_170); lean_inc(x_169); -x_170 = lean_ctor_get(x_3, 1); -lean_inc(x_170); -x_171 = lean_ctor_get_uint64(x_3, sizeof(void*)*2); -lean_inc(x_170); -x_172 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_170, x_4); -x_173 = !lean_is_exclusive(x_172); -if (x_173 == 0) +lean_dec(x_161); +x_171 = lean_array_uset(x_169, x_6, x_3); +lean_inc(x_163); +x_172 = lean_array_uset(x_170, x_6, x_163); +x_173 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_173, 0, x_171); +lean_ctor_set(x_173, 1, x_172); +lean_ctor_set(x_158, 1, x_173); +lean_ctor_set(x_158, 0, x_163); +return x_158; +} +} +else { -lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; uint8_t x_178; -x_174 = lean_ctor_get(x_172, 0); -x_175 = lean_ctor_get(x_172, 1); -x_176 = lean_ctor_get(x_175, 0); -lean_inc(x_176); -lean_inc(x_3); -x_177 = lean_array_uset(x_176, x_6, x_3); -x_178 = !lean_is_exclusive(x_3); -if (x_178 == 0) -{ -lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; -x_179 = lean_ctor_get(x_3, 1); -lean_dec(x_179); -x_180 = lean_ctor_get(x_3, 0); -lean_dec(x_180); -x_181 = lean_ctor_get(x_175, 1); -lean_inc(x_181); -lean_dec(x_175); -x_182 = lean_expr_update_mdata(x_3, x_174); -lean_inc(x_182); -x_183 = lean_array_uset(x_181, x_6, x_182); +lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; +x_174 = lean_ctor_get(x_158, 0); +x_175 = lean_ctor_get(x_158, 1); +lean_inc(x_175); +lean_inc(x_174); +lean_dec(x_158); +x_176 = lean_alloc_ctor(10, 2, 8); +lean_ctor_set(x_176, 0, x_155); +lean_ctor_set(x_176, 1, x_156); +lean_ctor_set_uint64(x_176, sizeof(void*)*2, x_157); +x_177 = lean_expr_update_mdata(x_176, x_174); +x_178 = lean_ctor_get(x_175, 0); +lean_inc(x_178); +x_179 = lean_ctor_get(x_175, 1); +lean_inc(x_179); +if (lean_is_exclusive(x_175)) { + lean_ctor_release(x_175, 0); + lean_ctor_release(x_175, 1); + x_180 = x_175; +} else { + lean_dec_ref(x_175); + x_180 = lean_box(0); +} +x_181 = lean_array_uset(x_178, x_6, x_3); +lean_inc(x_177); +x_182 = lean_array_uset(x_179, x_6, x_177); +if (lean_is_scalar(x_180)) { + x_183 = lean_alloc_ctor(0, 2, 0); +} else { + x_183 = x_180; +} +lean_ctor_set(x_183, 0, x_181); +lean_ctor_set(x_183, 1, x_182); x_184 = lean_alloc_ctor(0, 2, 0); lean_ctor_set(x_184, 0, x_177); lean_ctor_set(x_184, 1, x_183); -lean_ctor_set(x_172, 1, x_184); -lean_ctor_set(x_172, 0, x_182); -return x_172; -} -else -{ -lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; -lean_dec(x_3); -x_185 = lean_ctor_get(x_175, 1); -lean_inc(x_185); -lean_dec(x_175); -x_186 = lean_alloc_ctor(10, 2, 8); -lean_ctor_set(x_186, 0, x_169); -lean_ctor_set(x_186, 1, x_170); -lean_ctor_set_uint64(x_186, sizeof(void*)*2, x_171); -x_187 = lean_expr_update_mdata(x_186, x_174); -lean_inc(x_187); -x_188 = lean_array_uset(x_185, x_6, x_187); -x_189 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_189, 0, x_177); -lean_ctor_set(x_189, 1, x_188); -lean_ctor_set(x_172, 1, x_189); -lean_ctor_set(x_172, 0, x_187); -return x_172; -} -} -else -{ -lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; -x_190 = lean_ctor_get(x_172, 0); -x_191 = lean_ctor_get(x_172, 1); -lean_inc(x_191); -lean_inc(x_190); -lean_dec(x_172); -x_192 = lean_ctor_get(x_191, 0); -lean_inc(x_192); -lean_inc(x_3); -x_193 = lean_array_uset(x_192, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - x_194 = x_3; -} else { - lean_dec_ref(x_3); - x_194 = lean_box(0); -} -x_195 = lean_ctor_get(x_191, 1); -lean_inc(x_195); -lean_dec(x_191); -if (lean_is_scalar(x_194)) { - x_196 = lean_alloc_ctor(10, 2, 8); -} else { - x_196 = x_194; -} -lean_ctor_set(x_196, 0, x_169); -lean_ctor_set(x_196, 1, x_170); -lean_ctor_set_uint64(x_196, sizeof(void*)*2, x_171); -x_197 = lean_expr_update_mdata(x_196, x_190); -lean_inc(x_197); -x_198 = lean_array_uset(x_195, x_6, x_197); -x_199 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_199, 0, x_193); -lean_ctor_set(x_199, 1, x_198); -x_200 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_200, 0, x_197); -lean_ctor_set(x_200, 1, x_199); -return x_200; +return x_184; } } case 11: { -lean_object* x_201; lean_object* x_202; lean_object* x_203; uint64_t x_204; lean_object* x_205; uint8_t x_206; -x_201 = lean_ctor_get(x_3, 0); +lean_object* x_185; lean_object* x_186; lean_object* x_187; uint64_t x_188; lean_object* x_189; uint8_t x_190; +x_185 = lean_ctor_get(x_3, 0); +lean_inc(x_185); +x_186 = lean_ctor_get(x_3, 1); +lean_inc(x_186); +x_187 = lean_ctor_get(x_3, 2); +lean_inc(x_187); +x_188 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); +lean_inc(x_187); +x_189 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_187, x_4); +x_190 = !lean_is_exclusive(x_189); +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_189, 0); +x_192 = lean_ctor_get(x_189, 1); +x_193 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_193, 0, x_185); +lean_ctor_set(x_193, 1, x_186); +lean_ctor_set(x_193, 2, x_187); +lean_ctor_set_uint64(x_193, sizeof(void*)*3, x_188); +x_194 = lean_expr_update_proj(x_193, x_191); +x_195 = !lean_is_exclusive(x_192); +if (x_195 == 0) +{ +lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; +x_196 = lean_ctor_get(x_192, 0); +x_197 = lean_ctor_get(x_192, 1); +x_198 = lean_array_uset(x_196, x_6, x_3); +lean_inc(x_194); +x_199 = lean_array_uset(x_197, x_6, x_194); +lean_ctor_set(x_192, 1, x_199); +lean_ctor_set(x_192, 0, x_198); +lean_ctor_set(x_189, 0, x_194); +return x_189; +} +else +{ +lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; +x_200 = lean_ctor_get(x_192, 0); +x_201 = lean_ctor_get(x_192, 1); lean_inc(x_201); -x_202 = lean_ctor_get(x_3, 1); -lean_inc(x_202); -x_203 = lean_ctor_get(x_3, 2); -lean_inc(x_203); -x_204 = lean_ctor_get_uint64(x_3, sizeof(void*)*3); -lean_inc(x_203); -x_205 = l_Lean_Expr_ReplaceImpl_replaceUnsafeM_visit(x_1, x_2, x_203, x_4); -x_206 = !lean_is_exclusive(x_205); -if (x_206 == 0) +lean_inc(x_200); +lean_dec(x_192); +x_202 = lean_array_uset(x_200, x_6, x_3); +lean_inc(x_194); +x_203 = lean_array_uset(x_201, x_6, x_194); +x_204 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_204, 0, x_202); +lean_ctor_set(x_204, 1, x_203); +lean_ctor_set(x_189, 1, x_204); +lean_ctor_set(x_189, 0, x_194); +return x_189; +} +} +else { -lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; uint8_t x_211; -x_207 = lean_ctor_get(x_205, 0); -x_208 = lean_ctor_get(x_205, 1); -x_209 = lean_ctor_get(x_208, 0); +lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_205 = lean_ctor_get(x_189, 0); +x_206 = lean_ctor_get(x_189, 1); +lean_inc(x_206); +lean_inc(x_205); +lean_dec(x_189); +x_207 = lean_alloc_ctor(11, 3, 8); +lean_ctor_set(x_207, 0, x_185); +lean_ctor_set(x_207, 1, x_186); +lean_ctor_set(x_207, 2, x_187); +lean_ctor_set_uint64(x_207, sizeof(void*)*3, x_188); +x_208 = lean_expr_update_proj(x_207, x_205); +x_209 = lean_ctor_get(x_206, 0); lean_inc(x_209); -lean_inc(x_3); -x_210 = lean_array_uset(x_209, x_6, x_3); -x_211 = !lean_is_exclusive(x_3); -if (x_211 == 0) -{ -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; -x_212 = lean_ctor_get(x_3, 2); -lean_dec(x_212); -x_213 = lean_ctor_get(x_3, 1); -lean_dec(x_213); -x_214 = lean_ctor_get(x_3, 0); -lean_dec(x_214); -x_215 = lean_ctor_get(x_208, 1); -lean_inc(x_215); -lean_dec(x_208); -x_216 = lean_expr_update_proj(x_3, x_207); -lean_inc(x_216); -x_217 = lean_array_uset(x_215, x_6, x_216); -x_218 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_218, 0, x_210); -lean_ctor_set(x_218, 1, x_217); -lean_ctor_set(x_205, 1, x_218); -lean_ctor_set(x_205, 0, x_216); -return x_205; -} -else -{ -lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; -lean_dec(x_3); -x_219 = lean_ctor_get(x_208, 1); -lean_inc(x_219); -lean_dec(x_208); -x_220 = lean_alloc_ctor(11, 3, 8); -lean_ctor_set(x_220, 0, x_201); -lean_ctor_set(x_220, 1, x_202); -lean_ctor_set(x_220, 2, x_203); -lean_ctor_set_uint64(x_220, sizeof(void*)*3, x_204); -x_221 = lean_expr_update_proj(x_220, x_207); -lean_inc(x_221); -x_222 = lean_array_uset(x_219, x_6, x_221); -x_223 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_223, 0, x_210); -lean_ctor_set(x_223, 1, x_222); -lean_ctor_set(x_205, 1, x_223); -lean_ctor_set(x_205, 0, x_221); -return x_205; -} -} -else -{ -lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; -x_224 = lean_ctor_get(x_205, 0); -x_225 = lean_ctor_get(x_205, 1); -lean_inc(x_225); -lean_inc(x_224); -lean_dec(x_205); -x_226 = lean_ctor_get(x_225, 0); -lean_inc(x_226); -lean_inc(x_3); -x_227 = lean_array_uset(x_226, x_6, x_3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - x_228 = x_3; +x_210 = lean_ctor_get(x_206, 1); +lean_inc(x_210); +if (lean_is_exclusive(x_206)) { + lean_ctor_release(x_206, 0); + lean_ctor_release(x_206, 1); + x_211 = x_206; } else { - lean_dec_ref(x_3); - x_228 = lean_box(0); + lean_dec_ref(x_206); + x_211 = lean_box(0); } -x_229 = lean_ctor_get(x_225, 1); -lean_inc(x_229); -lean_dec(x_225); -if (lean_is_scalar(x_228)) { - x_230 = lean_alloc_ctor(11, 3, 8); +x_212 = lean_array_uset(x_209, x_6, x_3); +lean_inc(x_208); +x_213 = lean_array_uset(x_210, x_6, x_208); +if (lean_is_scalar(x_211)) { + x_214 = lean_alloc_ctor(0, 2, 0); } else { - x_230 = x_228; + x_214 = x_211; } -lean_ctor_set(x_230, 0, x_201); -lean_ctor_set(x_230, 1, x_202); -lean_ctor_set(x_230, 2, x_203); -lean_ctor_set_uint64(x_230, sizeof(void*)*3, x_204); -x_231 = lean_expr_update_proj(x_230, x_224); -lean_inc(x_231); -x_232 = lean_array_uset(x_229, x_6, x_231); -x_233 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_233, 0, x_227); -lean_ctor_set(x_233, 1, x_232); -x_234 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_234, 0, x_231); -lean_ctor_set(x_234, 1, x_233); -return x_234; +lean_ctor_set(x_214, 0, x_212); +lean_ctor_set(x_214, 1, x_213); +x_215 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_215, 0, x_208); +lean_ctor_set(x_215, 1, x_214); +return x_215; } } default: { -lean_object* x_235; +lean_object* x_216; lean_dec(x_1); -x_235 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_235, 0, x_3); -lean_ctor_set(x_235, 1, x_4); -return x_235; +x_216 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_216, 0, x_3); +lean_ctor_set(x_216, 1, x_4); +return x_216; } } } else { -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_217; uint8_t x_218; lean_dec(x_1); -x_236 = lean_ctor_get(x_11, 0); -lean_inc(x_236); +x_217 = lean_ctor_get(x_11, 0); +lean_inc(x_217); lean_dec(x_11); -x_237 = lean_array_uset(x_7, x_6, x_3); -x_238 = lean_ctor_get(x_4, 1); -lean_inc(x_238); +x_218 = !lean_is_exclusive(x_4); +if (x_218 == 0) +{ +lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; +x_219 = lean_ctor_get(x_4, 0); +x_220 = lean_ctor_get(x_4, 1); +x_221 = lean_array_uset(x_219, x_6, x_3); +lean_inc(x_217); +x_222 = lean_array_uset(x_220, x_6, x_217); +lean_ctor_set(x_4, 1, x_222); +lean_ctor_set(x_4, 0, x_221); +x_223 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_223, 0, x_217); +lean_ctor_set(x_223, 1, x_4); +return x_223; +} +else +{ +lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; +x_224 = lean_ctor_get(x_4, 0); +x_225 = lean_ctor_get(x_4, 1); +lean_inc(x_225); +lean_inc(x_224); lean_dec(x_4); -lean_inc(x_236); -x_239 = lean_array_uset(x_238, x_6, x_236); -x_240 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_240, 0, x_237); -lean_ctor_set(x_240, 1, x_239); -x_241 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_241, 0, x_236); -lean_ctor_set(x_241, 1, x_240); -return x_241; +x_226 = lean_array_uset(x_224, x_6, x_3); +lean_inc(x_217); +x_227 = lean_array_uset(x_225, x_6, x_217); +x_228 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_228, 0, x_226); +lean_ctor_set(x_228, 1, x_227); +x_229 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_229, 0, x_217); +lean_ctor_set(x_229, 1, x_228); +return x_229; +} } } else { -lean_object* x_242; lean_object* x_243; lean_object* x_244; -lean_dec(x_7); +lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_dec(x_3); lean_dec(x_1); -x_242 = lean_ctor_get(x_4, 1); -lean_inc(x_242); -x_243 = lean_array_uget(x_242, x_6); -lean_dec(x_242); -x_244 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_244, 0, x_243); -lean_ctor_set(x_244, 1, x_4); -return x_244; +x_230 = lean_ctor_get(x_4, 1); +lean_inc(x_230); +x_231 = lean_array_uget(x_230, x_6); +lean_dec(x_230); +x_232 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_232, 0, x_231); +lean_ctor_set(x_232, 1, x_4); +return x_232; } } } diff --git a/stage0/stdlib/Std/Control/Lawful.c b/stage0/stdlib/Std/Control/Lawful.c deleted file mode 100644 index d50d3ee9bc..0000000000 --- a/stage0/stdlib/Std/Control/Lawful.c +++ /dev/null @@ -1,29 +0,0 @@ -// Lean compiler output -// Module: Std.Control.Lawful -// Imports: Init -#include -#if defined(__clang__) -#pragma clang diagnostic ignored "-Wunused-parameter" -#pragma clang diagnostic ignored "-Wunused-label" -#elif defined(__GNUC__) && !defined(__CLANG__) -#pragma GCC diagnostic ignored "-Wunused-parameter" -#pragma GCC diagnostic ignored "-Wunused-label" -#pragma GCC diagnostic ignored "-Wunused-but-set-variable" -#endif -#ifdef __cplusplus -extern "C" { -#endif -lean_object* initialize_Init(lean_object*); -static bool _G_initialized = false; -lean_object* initialize_Std_Control_Lawful(lean_object* w) { -lean_object * res; -if (_G_initialized) return lean_io_result_mk_ok(lean_box(0)); -_G_initialized = true; -res = initialize_Init(lean_io_mk_world()); -if (lean_io_result_is_error(res)) return res; -lean_dec_ref(res); -return lean_io_result_mk_ok(lean_box(0)); -} -#ifdef __cplusplus -} -#endif