From ea3e27bbc4c9d03353a99f91fb7f88aa075cae8a Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Thu, 23 Jun 2022 16:13:49 -0700 Subject: [PATCH] chore: update stage0 --- stage0/src/Lean/Declaration.lean | 33 +- stage0/src/Lean/Elab/Binders.lean | 8 +- stage0/src/Lean/Elab/PreDefinition/Basic.lean | 7 +- stage0/src/Lean/Elab/Tactic/ElabTerm.lean | 8 +- stage0/src/Lean/Elab/Term.lean | 6 +- stage0/src/Lean/Meta/Closure.lean | 10 +- stage0/src/Lean/Meta/Injective.lean | 3 +- stage0/src/Lean/Meta/Tactic/AuxLemma.lean | 6 +- stage0/src/Lean/ParserCompiler.lean | 5 +- stage0/src/kernel/declaration.cpp | 18 +- stage0/src/kernel/declaration.h | 4 +- stage0/stdlib/Lean/Compiler/InitAttr.c | 285 +- stage0/stdlib/Lean/Declaration.c | 218 +- stage0/stdlib/Lean/Elab/Binders.c | 194 +- stage0/stdlib/Lean/Elab/BuiltinCommand.c | 1304 ++++----- stage0/stdlib/Lean/Elab/Deriving/DecEq.c | 140 +- stage0/stdlib/Lean/Elab/MutualDef.c | 1323 ++++----- stage0/stdlib/Lean/Elab/PreDefinition/Basic.c | 931 ++++--- stage0/stdlib/Lean/Elab/PreDefinition/Eqns.c | 167 +- .../Lean/Elab/PreDefinition/Structural/Eqns.c | 1042 +++---- .../stdlib/Lean/Elab/PreDefinition/WF/Eqns.c | 1064 ++++---- stage0/stdlib/Lean/Elab/Print.c | 4 +- stage0/stdlib/Lean/Elab/Structure.c | 735 ++--- stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c | 151 +- stage0/stdlib/Lean/Elab/Term.c | 145 +- stage0/stdlib/Lean/Meta/Closure.c | 568 ++-- stage0/stdlib/Lean/Meta/Constructions.c | 1276 ++++----- stage0/stdlib/Lean/Meta/Eqns.c | 528 ++-- stage0/stdlib/Lean/Meta/IndPredBelow.c | 246 +- stage0/stdlib/Lean/Meta/Injective.c | 580 ++-- stage0/stdlib/Lean/Meta/Match/Match.c | 598 ++-- stage0/stdlib/Lean/Meta/Match/MatchEqs.c | 2399 +++++++++-------- stage0/stdlib/Lean/Meta/SizeOf.c | 1317 ++++----- stage0/stdlib/Lean/Meta/Tactic/AuxLemma.c | 1412 +++++----- stage0/stdlib/Lean/ParserCompiler.c | 2290 ++++++++-------- .../stdlib/Lean/Server/Rpc/RequestHandling.c | 105 +- 36 files changed, 9829 insertions(+), 9301 deletions(-) diff --git a/stage0/src/Lean/Declaration.lean b/stage0/src/Lean/Declaration.lean index 04e5c5769e..f93a11f1c3 100644 --- a/stage0/src/Lean/Declaration.lean +++ b/stage0/src/Lean/Declaration.lean @@ -95,16 +95,19 @@ structure DefinitionVal extends ConstantVal where value : Expr hints : ReducibilityHints safety : DefinitionSafety + /-- + List of all (including this one) declarations in the same mutual block. + Note that this information is not used by the kernel, and is only used + to save the information provided by the user when using mutual blocks. + Recall that the Lean kernel does not support recursive definitions and they + are compiled using recursors and `WellFounded.fix`. + -/ + all : List Name := [name] deriving Inhabited @[export lean_mk_definition_val] -def mkDefinitionValEx (name : Name) (levelParams : List Name) (type : Expr) (val : Expr) (hints : ReducibilityHints) (safety : DefinitionSafety) : DefinitionVal := { - name := name, - levelParams := levelParams, - type := type, - value := val, - hints := hints, - safety := safety +def mkDefinitionValEx (name : Name) (levelParams : List Name) (type : Expr) (value : Expr) (hints : ReducibilityHints) (safety : DefinitionSafety) (all : List Name) : DefinitionVal := { + name, levelParams, type, hints, safety, value, all } @[export lean_definition_val_get_safety] def DefinitionVal.getSafetyEx (v : DefinitionVal) : DefinitionSafety := @@ -112,21 +115,25 @@ def mkDefinitionValEx (name : Name) (levelParams : List Name) (type : Expr) (val structure TheoremVal extends ConstantVal where value : Expr + /-- + List of all (including this one) declarations in the same mutual block. + See comment at `DefinitionVal.all`. -/ + all : List Name := [name] deriving Inhabited /- Value for an opaque constant declaration `constant x : t := e` -/ structure OpaqueVal extends ConstantVal where value : Expr isUnsafe : Bool + /-- + List of all (including this one) declarations in the same mutual block. + See comment at `DefinitionVal.all`. -/ + all : List Name := [name] deriving Inhabited @[export lean_mk_opaque_val] -def mkOpaqueValEx (name : Name) (levelParams : List Name) (type : Expr) (val : Expr) (isUnsafe : Bool) : OpaqueVal := { - name := name, - levelParams := levelParams, - type := type, - value := val, - isUnsafe := isUnsafe +def mkOpaqueValEx (name : Name) (levelParams : List Name) (type : Expr) (value : Expr) (isUnsafe : Bool) (all : List Name) : OpaqueVal := { + name, levelParams, type, value, isUnsafe, all } @[export lean_opaque_val_is_unsafe] def OpaqueVal.isUnsafeEx (v : OpaqueVal) : Bool := diff --git a/stage0/src/Lean/Elab/Binders.lean b/stage0/src/Lean/Elab/Binders.lean index e3f803607c..f09d3834bb 100644 --- a/stage0/src/Lean/Elab/Binders.lean +++ b/stage0/src/Lean/Elab/Binders.lean @@ -65,10 +65,10 @@ def declareTacticSyntax (tactic : Syntax) : TermElabM Name := let name ← MonadQuotation.addMacroScope `_auto let type := Lean.mkConst `Lean.Syntax let tactic ← quoteAutoTactic tactic - let val ← elabTerm tactic type - let val ← instantiateMVars val - trace[Elab.autoParam] val - let decl := Declaration.defnDecl { name := name, levelParams := [], type := type, value := val, hints := ReducibilityHints.opaque, + let value ← elabTerm tactic type + let value ← instantiateMVars value + trace[Elab.autoParam] value + let decl := Declaration.defnDecl { name, levelParams := [], type, value, hints := .opaque, safety := DefinitionSafety.safe } addDecl decl compileDecl decl diff --git a/stage0/src/Lean/Elab/PreDefinition/Basic.lean b/stage0/src/Lean/Elab/PreDefinition/Basic.lean index 200bebccd0..aa9c37a5ec 100644 --- a/stage0/src/Lean/Elab/PreDefinition/Basic.lean +++ b/stage0/src/Lean/Elab/PreDefinition/Basic.lean @@ -98,11 +98,14 @@ private def addNonRecAux (preDef : PreDefinition) (compile : Bool) (applyAttrAft let decl ← match preDef.kind with | DefKind.«theorem» => - pure <| Declaration.thmDecl { name := preDef.declName, levelParams := preDef.levelParams, type := preDef.type, value := preDef.value } + pure <| Declaration.thmDecl { + name := preDef.declName, levelParams := preDef.levelParams, type := preDef.type, value := preDef.value + } | DefKind.«opaque» => pure <| Declaration.opaqueDecl { name := preDef.declName, levelParams := preDef.levelParams, type := preDef.type, value := preDef.value - isUnsafe := preDef.modifiers.isUnsafe } + isUnsafe := preDef.modifiers.isUnsafe + } | DefKind.«abbrev» => pure <| Declaration.defnDecl { name := preDef.declName, levelParams := preDef.levelParams, type := preDef.type, value := preDef.value diff --git a/stage0/src/Lean/Elab/Tactic/ElabTerm.lean b/stage0/src/Lean/Elab/Tactic/ElabTerm.lean index b3d2efc8f3..c19ebbc9fe 100644 --- a/stage0/src/Lean/Elab/Tactic/ElabTerm.lean +++ b/stage0/src/Lean/Elab/Tactic/ElabTerm.lean @@ -283,12 +283,12 @@ private def preprocessPropToDecide (expectedType : Expr) : TermElabM Expr := do let rflPrf ← mkEqRefl (toExpr true) return mkApp3 (Lean.mkConst ``of_decide_eq_true) expectedType s rflPrf -private def mkNativeAuxDecl (baseName : Name) (type val : Expr) : TermElabM Name := do +private def mkNativeAuxDecl (baseName : Name) (type value : Expr) : TermElabM Name := do let auxName ← Term.mkAuxName baseName let decl := Declaration.defnDecl { - name := auxName, levelParams := [], type := type, value := val, - hints := ReducibilityHints.abbrev, - safety := DefinitionSafety.safe + name := auxName, levelParams := [], type, value + hints := .abbrev + safety := .safe } addDecl decl compileDecl decl diff --git a/stage0/src/Lean/Elab/Term.lean b/stage0/src/Lean/Elab/Term.lean index f08f935a3c..b0ccbce943 100644 --- a/stage0/src/Lean/Elab/Term.lean +++ b/stage0/src/Lean/Elab/Term.lean @@ -1590,9 +1590,9 @@ unsafe def evalExpr (α) (typeName : Name) (value : Expr) : TermElabM α := unless type.isConstOf typeName do throwError "unexpected type at evalExpr{indentExpr type}" let decl := Declaration.defnDecl { - name := name, levelParams := [], type := type, - value := value, hints := ReducibilityHints.opaque, - safety := DefinitionSafety.unsafe + name, levelParams := [], type + value, hints := ReducibilityHints.opaque, + safety := .unsafe } ensureNoUnassignedMVars decl addAndCompile decl diff --git a/stage0/src/Lean/Meta/Closure.lean b/stage0/src/Lean/Meta/Closure.lean index 42de3cdd28..2a9def77bc 100644 --- a/stage0/src/Lean/Meta/Closure.lean +++ b/stage0/src/Lean/Meta/Closure.lean @@ -350,11 +350,11 @@ def mkAuxDefinition (name : Name) (type : Expr) (value : Expr) (zeta : Bool := f let result ← Closure.mkValueTypeClosure type value zeta let env ← getEnv let decl := Declaration.defnDecl { - name := name, - levelParams := result.levelParams.toList, - type := result.type, - value := result.value, - hints := ReducibilityHints.regular (getMaxHeight env result.value + 1), + name := name + levelParams := result.levelParams.toList + type := result.type + value := result.value + hints := ReducibilityHints.regular (getMaxHeight env result.value + 1) safety := if env.hasUnsafe result.type || env.hasUnsafe result.value then DefinitionSafety.unsafe else DefinitionSafety.safe } addDecl decl diff --git a/stage0/src/Lean/Meta/Injective.lean b/stage0/src/Lean/Meta/Injective.lean index 31a4fe9750..65ea5e2fdb 100644 --- a/stage0/src/Lean/Meta/Injective.lean +++ b/stage0/src/Lean/Meta/Injective.lean @@ -101,8 +101,9 @@ private def mkInjectiveTheorem (ctorVal : ConstructorVal) : MetaM Unit := do let some type ← mkInjectiveTheoremType? ctorVal | return () let value ← mkInjectiveTheoremValue ctorVal.name type + let name := mkInjectiveTheoremNameFor ctorVal.name addDecl <| Declaration.thmDecl { - name := mkInjectiveTheoremNameFor ctorVal.name + name levelParams := ctorVal.levelParams type := (← instantiateMVars type) value := (← instantiateMVars value) diff --git a/stage0/src/Lean/Meta/Tactic/AuxLemma.lean b/stage0/src/Lean/Meta/Tactic/AuxLemma.lean index 95c72863a7..1e9a3ba288 100644 --- a/stage0/src/Lean/Meta/Tactic/AuxLemma.lean +++ b/stage0/src/Lean/Meta/Tactic/AuxLemma.lean @@ -29,10 +29,8 @@ def mkAuxLemma (levelParams : List Name) (type : Expr) (value : Expr) : MetaM Na let mkNewAuxLemma := do let auxName := Name.mkNum (env.mainModule ++ `_auxLemma) s.idx addDecl <| Declaration.thmDecl { - name := auxName - levelParams := levelParams - type := type - value := value + name := auxName + levelParams, type, value } modifyEnv fun env => auxLemmasExt.modifyState env fun ⟨idx, lemmas⟩ => ⟨idx + 1, lemmas.insert type (auxName, levelParams)⟩ return auxName diff --git a/stage0/src/Lean/ParserCompiler.lean b/stage0/src/Lean/ParserCompiler.lean index 64d126467c..a8692e0aba 100644 --- a/stage0/src/Lean/ParserCompiler.lean +++ b/stage0/src/Lean/ParserCompiler.lean @@ -97,8 +97,9 @@ partial def compileParserExpr (e : Expr) : MetaM Expr := do let paramTy ← replaceParserTy ctx <$> inferType param return mkForall `_ BinderInfo.default paramTy ty let decl := Declaration.defnDecl { - name := c', levelParams := [], - type := ty, value := value, hints := ReducibilityHints.opaque, safety := DefinitionSafety.safe } + name := c', levelParams := [] + type := ty, value := value, hints := ReducibilityHints.opaque, safety := DefinitionSafety.safe + } let env ← getEnv let env ← match env.addAndCompile {} decl with | Except.ok env => pure env diff --git a/stage0/src/kernel/declaration.cpp b/stage0/src/kernel/declaration.cpp index 408d218ed7..122de461e9 100644 --- a/stage0/src/kernel/declaration.cpp +++ b/stage0/src/kernel/declaration.cpp @@ -62,12 +62,12 @@ axiom_val::axiom_val(name const & n, names const & lparams, expr const & type, b bool axiom_val::is_unsafe() const { return lean_axiom_val_is_unsafe(to_obj_arg()); } -extern "C" object * lean_mk_definition_val(object * n, object * lparams, object * type, object * value, object * hints, uint8 safety); +extern "C" object * lean_mk_definition_val(object * n, object * lparams, object * type, object * value, object * hints, uint8 safety, object * all); extern "C" uint8 lean_definition_val_get_safety(object * v); -definition_val::definition_val(name const & n, names const & lparams, expr const & type, expr const & val, reducibility_hints const & hints, definition_safety safety): +definition_val::definition_val(name const & n, names const & lparams, expr const & type, expr const & val, reducibility_hints const & hints, definition_safety safety, names const & all): object_ref(lean_mk_definition_val(n.to_obj_arg(), lparams.to_obj_arg(), type.to_obj_arg(), val.to_obj_arg(), - hints.to_obj_arg(), static_cast(safety))) { + hints.to_obj_arg(), static_cast(safety), all.to_obj_arg())) { } definition_safety definition_val::get_safety() const { return static_cast(lean_definition_val_get_safety(to_obj_arg())); } @@ -76,11 +76,11 @@ theorem_val::theorem_val(name const & n, names const & lparams, expr const & typ object_ref(mk_cnstr(0, constant_val(n, lparams, type), val)) { } -extern "C" object * lean_mk_opaque_val(object * n, object * lparams, object * type, object * value, uint8 is_unsafe); +extern "C" object * lean_mk_opaque_val(object * n, object * lparams, object * type, object * value, uint8 is_unsafe, object * all); extern "C" uint8 lean_opaque_val_is_unsafe(object * v); -opaque_val::opaque_val(name const & n, names const & lparams, expr const & type, expr const & val, bool is_unsafe): - object_ref(lean_mk_opaque_val(n.to_obj_arg(), lparams.to_obj_arg(), type.to_obj_arg(), val.to_obj_arg(), is_unsafe)) { +opaque_val::opaque_val(name const & n, names const & lparams, expr const & type, expr const & val, bool is_unsafe, names const & all): + object_ref(lean_mk_opaque_val(n.to_obj_arg(), lparams.to_obj_arg(), type.to_obj_arg(), val.to_obj_arg(), is_unsafe, all.to_obj_arg())) { } bool opaque_val::is_unsafe() const { return lean_opaque_val_is_unsafe(to_obj_arg()); } @@ -193,12 +193,12 @@ static unsigned get_max_height(environment const & env, expr const & v) { definition_val mk_definition_val(environment const & env, name const & n, names const & params, expr const & t, expr const & v, definition_safety s) { unsigned h = get_max_height(env, v); - return definition_val(n, params, t, v, reducibility_hints::mk_regular(h+1), s); + return definition_val(n, params, t, v, reducibility_hints::mk_regular(h+1), s, names(n)); } declaration mk_definition(name const & n, names const & params, expr const & t, expr const & v, reducibility_hints const & h, definition_safety safety) { - return declaration(mk_cnstr(static_cast(declaration_kind::Definition), definition_val(n, params, t, v, h, safety))); + return declaration(mk_cnstr(static_cast(declaration_kind::Definition), definition_val(n, params, t, v, h, safety, names(n)))); } declaration mk_definition(environment const & env, name const & n, names const & params, expr const & t, @@ -207,7 +207,7 @@ declaration mk_definition(environment const & env, name const & n, names const & } declaration mk_opaque(name const & n, names const & params, expr const & t, expr const & v, bool is_unsafe) { - return declaration(mk_cnstr(static_cast(declaration_kind::Opaque), opaque_val(n, params, t, v, is_unsafe))); + return declaration(mk_cnstr(static_cast(declaration_kind::Opaque), opaque_val(n, params, t, v, is_unsafe, names(n)))); } declaration mk_axiom(name const & n, names const & params, expr const & t, bool unsafe) { diff --git a/stage0/src/kernel/declaration.h b/stage0/src/kernel/declaration.h index 265482de61..470363fed8 100644 --- a/stage0/src/kernel/declaration.h +++ b/stage0/src/kernel/declaration.h @@ -95,7 +95,7 @@ structure definition_val extends constant_val := */ class definition_val : public object_ref { public: - definition_val(name const & n, names const & lparams, expr const & type, expr const & val, reducibility_hints const & hints, definition_safety safety); + definition_val(name const & n, names const & lparams, expr const & type, expr const & val, reducibility_hints const & hints, definition_safety safety, names const & all); definition_val(definition_val const & other):object_ref(other) {} definition_val(definition_val && other):object_ref(other) {} definition_val & operator=(definition_val const & other) { object_ref::operator=(other); return *this; } @@ -135,7 +135,7 @@ structure opaque_val extends constant_val := */ class opaque_val : public object_ref { public: - opaque_val(name const & n, names const & lparams, expr const & type, expr const & val, bool is_unsafe); + opaque_val(name const & n, names const & lparams, expr const & type, expr const & val, bool is_unsafe, names const & all); opaque_val(opaque_val const & other):object_ref(other) {} opaque_val(opaque_val && other):object_ref(other) {} opaque_val & operator=(opaque_val const & other) { object_ref::operator=(other); return *this; } diff --git a/stage0/stdlib/Lean/Compiler/InitAttr.c b/stage0/stdlib/Lean/Compiler/InitAttr.c index c9b14a5e6b..a2ba0c4e8b 100644 --- a/stage0/stdlib/Lean/Compiler/InitAttr.c +++ b/stage0/stdlib/Lean/Compiler/InitAttr.c @@ -3017,7 +3017,7 @@ return x_2; LEAN_EXPORT lean_object* l_Lean_declareBuiltin(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { _start: { -lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; uint8_t x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +lean_object* x_6; lean_object* x_7; lean_object* x_8; lean_object* x_9; lean_object* x_10; lean_object* x_11; lean_object* x_12; uint8_t x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; x_6 = l_Lean_declareBuiltin___closed__2; lean_inc(x_1); x_7 = l_Lean_Name_append(x_6, x_1); @@ -3028,192 +3028,197 @@ x_10 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_10, 0, x_7); lean_ctor_set(x_10, 1, x_8); lean_ctor_set(x_10, 2, x_9); -x_11 = lean_box(0); -x_12 = 1; -x_13 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_13, 0, x_10); -lean_ctor_set(x_13, 1, x_2); -lean_ctor_set(x_13, 2, x_11); -lean_ctor_set_uint8(x_13, sizeof(void*)*3, x_12); -x_14 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_14, 0, x_13); -x_15 = lean_st_ref_get(x_4, x_5); -x_16 = lean_ctor_get(x_15, 0); -lean_inc(x_16); -x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_7); +x_11 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_11, 0, x_7); +lean_ctor_set(x_11, 1, x_8); +x_12 = lean_box(0); +x_13 = 1; +x_14 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_14, 0, x_10); +lean_ctor_set(x_14, 1, x_2); +lean_ctor_set(x_14, 2, x_12); +lean_ctor_set(x_14, 3, x_11); +lean_ctor_set_uint8(x_14, sizeof(void*)*4, x_13); +x_15 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_15, 0, x_14); +x_16 = lean_st_ref_get(x_4, x_5); +x_17 = lean_ctor_get(x_16, 0); lean_inc(x_17); -lean_dec(x_15); -x_18 = lean_ctor_get(x_16, 0); +x_18 = lean_ctor_get(x_16, 1); lean_inc(x_18); lean_dec(x_16); -x_19 = l_Lean_Environment_addAndCompile(x_18, x_8, x_14); -lean_dec(x_14); -if (lean_obj_tag(x_19) == 0) +x_19 = lean_ctor_get(x_17, 0); +lean_inc(x_19); +lean_dec(x_17); +x_20 = l_Lean_Environment_addAndCompile(x_19, x_8, x_15); +lean_dec(x_15); +if (lean_obj_tag(x_20) == 0) { -lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_dec(x_7); -x_20 = lean_ctor_get(x_19, 0); -lean_inc(x_20); -lean_dec(x_19); -x_21 = l_Lean_KernelException_toMessageData(x_20, x_8); -x_22 = lean_st_ref_get(x_4, x_17); -x_23 = lean_ctor_get(x_22, 1); -lean_inc(x_23); -lean_dec(x_22); -x_24 = lean_ctor_get(x_3, 5); +x_21 = lean_ctor_get(x_20, 0); +lean_inc(x_21); +lean_dec(x_20); +x_22 = l_Lean_KernelException_toMessageData(x_21, x_8); +x_23 = lean_st_ref_get(x_4, x_18); +x_24 = lean_ctor_get(x_23, 1); lean_inc(x_24); -x_25 = l_Lean_MessageData_toString(x_21, x_23); -if (lean_obj_tag(x_25) == 0) +lean_dec(x_23); +x_25 = lean_ctor_get(x_3, 5); +lean_inc(x_25); +x_26 = l_Lean_MessageData_toString(x_22, x_24); +if (lean_obj_tag(x_26) == 0) { -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; -lean_dec(x_24); -x_26 = lean_ctor_get(x_25, 0); -lean_inc(x_26); -x_27 = lean_ctor_get(x_25, 1); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_25); +x_27 = lean_ctor_get(x_26, 0); lean_inc(x_27); -lean_dec(x_25); -x_28 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_28, 0, x_1); -x_29 = l_Lean_declareBuiltin___closed__9; -x_30 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_30, 0, x_29); -lean_ctor_set(x_30, 1, x_28); -x_31 = l_Lean_declareBuiltin___closed__11; -x_32 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_32, 0, x_30); -lean_ctor_set(x_32, 1, x_31); -x_33 = l_Lean_stringToMessageData(x_26); +x_28 = lean_ctor_get(x_26, 1); +lean_inc(x_28); lean_dec(x_26); -x_34 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_34, 0, x_32); -lean_ctor_set(x_34, 1, x_33); -x_35 = l_Lean_declareBuiltin___closed__12; -x_36 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_36, 0, x_34); -lean_ctor_set(x_36, 1, x_35); -x_37 = l_Lean_throwError___at_Lean_declareBuiltin___spec__1(x_36, x_3, x_4, x_27); +x_29 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_29, 0, x_1); +x_30 = l_Lean_declareBuiltin___closed__9; +x_31 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_31, 0, x_30); +lean_ctor_set(x_31, 1, x_29); +x_32 = l_Lean_declareBuiltin___closed__11; +x_33 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +x_34 = l_Lean_stringToMessageData(x_27); +lean_dec(x_27); +x_35 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +x_36 = l_Lean_declareBuiltin___closed__12; +x_37 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_37, 0, x_35); +lean_ctor_set(x_37, 1, x_36); +x_38 = l_Lean_throwError___at_Lean_declareBuiltin___spec__1(x_37, x_3, x_4, x_28); lean_dec(x_4); lean_dec(x_3); -return x_37; +return x_38; } else { -uint8_t x_38; +uint8_t x_39; lean_dec(x_4); lean_dec(x_3); lean_dec(x_1); -x_38 = !lean_is_exclusive(x_25); -if (x_38 == 0) +x_39 = !lean_is_exclusive(x_26); +if (x_39 == 0) { -lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; -x_39 = lean_ctor_get(x_25, 0); -x_40 = lean_io_error_to_string(x_39); -x_41 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_41, 0, x_40); -x_42 = lean_alloc_ctor(0, 1, 0); +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_40 = lean_ctor_get(x_26, 0); +x_41 = lean_io_error_to_string(x_40); +x_42 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_42, 0, x_41); -x_43 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_43, 0, x_24); -lean_ctor_set(x_43, 1, x_42); -lean_ctor_set(x_25, 0, x_43); -return x_25; +x_43 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_43, 0, x_42); +x_44 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_44, 0, x_25); +lean_ctor_set(x_44, 1, x_43); +lean_ctor_set(x_26, 0, x_44); +return x_26; } else { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; -x_44 = lean_ctor_get(x_25, 0); -x_45 = lean_ctor_get(x_25, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_45 = lean_ctor_get(x_26, 0); +x_46 = lean_ctor_get(x_26, 1); +lean_inc(x_46); lean_inc(x_45); -lean_inc(x_44); -lean_dec(x_25); -x_46 = lean_io_error_to_string(x_44); -x_47 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_26); +x_47 = lean_io_error_to_string(x_45); +x_48 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_48, 0, x_47); -x_49 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_49, 0, x_24); -lean_ctor_set(x_49, 1, x_48); -x_50 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_50, 0, x_49); -lean_ctor_set(x_50, 1, x_45); -return x_50; +x_49 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_49, 0, x_48); +x_50 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_50, 0, x_25); +lean_ctor_set(x_50, 1, x_49); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_50); +lean_ctor_set(x_51, 1, x_46); +return x_51; } } } else { -lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_dec(x_1); -x_51 = lean_ctor_get(x_19, 0); -lean_inc(x_51); -lean_dec(x_19); -x_52 = l_Lean_getBuiltinInitFnNameFor_x3f___closed__1; -x_53 = lean_box(0); -x_54 = l_Lean_ParametricAttribute_setParam___rarg(x_52, x_51, x_7, x_53); -x_55 = lean_st_ref_get(x_4, x_17); -x_56 = lean_ctor_get(x_55, 1); -lean_inc(x_56); -lean_dec(x_55); -x_57 = lean_ctor_get(x_3, 5); +x_52 = lean_ctor_get(x_20, 0); +lean_inc(x_52); +lean_dec(x_20); +x_53 = l_Lean_getBuiltinInitFnNameFor_x3f___closed__1; +x_54 = lean_box(0); +x_55 = l_Lean_ParametricAttribute_setParam___rarg(x_53, x_52, x_7, x_54); +x_56 = lean_st_ref_get(x_4, x_18); +x_57 = lean_ctor_get(x_56, 1); lean_inc(x_57); -x_58 = l_IO_ofExcept___at_Lean_declareBuiltin___spec__2(x_54, x_56); -lean_dec(x_54); -if (lean_obj_tag(x_58) == 0) +lean_dec(x_56); +x_58 = lean_ctor_get(x_3, 5); +lean_inc(x_58); +x_59 = l_IO_ofExcept___at_Lean_declareBuiltin___spec__2(x_55, x_57); +lean_dec(x_55); +if (lean_obj_tag(x_59) == 0) { -lean_object* x_59; lean_object* x_60; lean_object* x_61; -lean_dec(x_57); -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); -x_60 = lean_ctor_get(x_58, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; +lean_dec(x_58); +x_60 = lean_ctor_get(x_59, 0); lean_inc(x_60); -lean_dec(x_58); -x_61 = l_Lean_setEnv___at_Lean_declareBuiltin___spec__3(x_59, x_3, x_4, x_60); +x_61 = lean_ctor_get(x_59, 1); +lean_inc(x_61); +lean_dec(x_59); +x_62 = l_Lean_setEnv___at_Lean_declareBuiltin___spec__3(x_60, x_3, x_4, x_61); lean_dec(x_4); lean_dec(x_3); -return x_61; +return x_62; } else { -uint8_t x_62; +uint8_t x_63; lean_dec(x_4); lean_dec(x_3); -x_62 = !lean_is_exclusive(x_58); -if (x_62 == 0) +x_63 = !lean_is_exclusive(x_59); +if (x_63 == 0) { -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_63 = lean_ctor_get(x_58, 0); -x_64 = lean_io_error_to_string(x_63); -x_65 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_65, 0, x_64); -x_66 = lean_alloc_ctor(0, 1, 0); +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_59, 0); +x_65 = lean_io_error_to_string(x_64); +x_66 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_66, 0, x_65); -x_67 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_67, 0, x_57); -lean_ctor_set(x_67, 1, x_66); -lean_ctor_set(x_58, 0, x_67); -return x_58; +x_67 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_67, 0, x_66); +x_68 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_68, 0, x_58); +lean_ctor_set(x_68, 1, x_67); +lean_ctor_set(x_59, 0, x_68); +return x_59; } else { -lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; -x_68 = lean_ctor_get(x_58, 0); -x_69 = lean_ctor_get(x_58, 1); +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_69 = lean_ctor_get(x_59, 0); +x_70 = lean_ctor_get(x_59, 1); +lean_inc(x_70); lean_inc(x_69); -lean_inc(x_68); -lean_dec(x_58); -x_70 = lean_io_error_to_string(x_68); -x_71 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_71, 0, x_70); -x_72 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_59); +x_71 = lean_io_error_to_string(x_69); +x_72 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_72, 0, x_71); -x_73 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_73, 0, x_57); -lean_ctor_set(x_73, 1, x_72); -x_74 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_74, 0, x_73); -lean_ctor_set(x_74, 1, x_69); -return x_74; +x_73 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_73, 0, x_72); +x_74 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_74, 0, x_58); +lean_ctor_set(x_74, 1, x_73); +x_75 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_75, 0, x_74); +lean_ctor_set(x_75, 1, x_70); +return x_75; } } } diff --git a/stage0/stdlib/Lean/Declaration.c b/stage0/stdlib/Lean/Declaration.c index b20c669ed2..2e0fe609cb 100644 --- a/stage0/stdlib/Lean/Declaration.c +++ b/stage0/stdlib/Lean/Declaration.c @@ -119,7 +119,7 @@ LEAN_EXPORT lean_object* l_List_foldlM___at_Lean_Declaration_forExprM___spec__2_ LEAN_EXPORT lean_object* l_Lean_instInhabitedInductiveType; static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__11; LEAN_EXPORT uint8_t l_Lean_ConstantInfo_hasValue(lean_object*); -LEAN_EXPORT lean_object* l_Lean_mkOpaqueValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkOpaqueValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__12; LEAN_EXPORT lean_object* l_Lean_RecursorVal_getFirstIndexIdx___boxed(lean_object*); LEAN_EXPORT lean_object* l_Lean_Declaration_isUnsafeInductiveDeclEx___boxed(lean_object*); @@ -135,8 +135,10 @@ LEAN_EXPORT lean_object* l_Lean_ConstantInfo_isInductive___boxed(lean_object*); LEAN_EXPORT lean_object* l_Lean_ConstantInfo_isCtor___boxed(lean_object*); LEAN_EXPORT lean_object* l_Lean_ConstantInfo_hints(lean_object*); LEAN_EXPORT lean_object* l_Lean_mkQuotValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_DefinitionVal_all___default___boxed(lean_object*); LEAN_EXPORT lean_object* l_Lean_ConstantInfo_type(lean_object*); LEAN_EXPORT lean_object* l_Lean_ConstantInfo_value_x3f(lean_object*); +LEAN_EXPORT lean_object* l_Lean_DefinitionVal_all___default(lean_object*); LEAN_EXPORT lean_object* lean_mk_recursor_val(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, uint8_t); LEAN_EXPORT lean_object* l_Lean_instInhabitedConstructor; LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___at_Lean_Declaration_forExprM___spec__1___rarg(lean_object*, lean_object*, lean_object*, lean_object*); @@ -145,7 +147,7 @@ LEAN_EXPORT uint8_t l_Lean_instInhabitedDefinitionSafety; LEAN_EXPORT uint8_t lean_recursor_is_unsafe(lean_object*); LEAN_EXPORT lean_object* l_Lean_RecursorVal_getInduct(lean_object*); LEAN_EXPORT lean_object* lean_mk_constructor_val(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); -LEAN_EXPORT lean_object* l_Lean_mkDefinitionValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkDefinitionValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_instInhabitedDeclaration___closed__1; LEAN_EXPORT lean_object* l_Lean_ReducibilityHints_getHeightEx___boxed(lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____boxed(lean_object*, lean_object*); @@ -155,6 +157,7 @@ LEAN_EXPORT uint8_t l___private_Lean_Declaration_0__Lean_beqDefinitionSafety____ LEAN_EXPORT lean_object* l_Lean_mkAxiomValEx___boxed(lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__17; LEAN_EXPORT lean_object* l_List_foldlM___at_Lean_Declaration_forExprM___spec__4___rarg(lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_TheoremVal_all___default___boxed(lean_object*); LEAN_EXPORT uint8_t l_Lean_ConstantInfo_isCtor(lean_object*); LEAN_EXPORT lean_object* l_Lean_instReprDefinitionSafety; LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___rarg___lambda__1(lean_object*, lean_object*, lean_object*); @@ -167,6 +170,7 @@ LEAN_EXPORT uint8_t lean_inductive_val_is_unsafe(lean_object*); static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__2; LEAN_EXPORT uint8_t lean_quot_val_kind(lean_object*); lean_object* l_Lean_Name_getPrefix(lean_object*); +LEAN_EXPORT lean_object* l_Lean_TheoremVal_all___default(lean_object*); LEAN_EXPORT lean_object* l_List_foldlM___at_Lean_Declaration_forExprM___spec__4___rarg___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_nat_dec_eq(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_instInhabitedQuotVal; @@ -174,7 +178,7 @@ LEAN_EXPORT lean_object* l_Lean_mkInductiveDeclEs___boxed(lean_object*, lean_obj static lean_object* l_Lean_instInhabitedConstantVal___closed__2; LEAN_EXPORT lean_object* l_Lean_ConstantInfo_name___boxed(lean_object*); static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__19; -LEAN_EXPORT lean_object* lean_mk_definition_val(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* lean_mk_definition_val(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___at_Lean_Declaration_forExprM___spec__1(lean_object*); static lean_object* l_Lean_instInhabitedConstantInfo___closed__1; static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__1; @@ -182,7 +186,7 @@ LEAN_EXPORT lean_object* l_Lean_instInhabitedRecursorVal; LEAN_EXPORT lean_object* l_Lean_instInhabitedDeclaration; LEAN_EXPORT lean_object* l_Lean_instInhabitedTheoremVal; static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__9; -LEAN_EXPORT lean_object* lean_mk_opaque_val(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t); +LEAN_EXPORT lean_object* lean_mk_opaque_val(lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*); static lean_object* l___private_Lean_Declaration_0__Lean_reprDefinitionSafety____x40_Lean_Declaration___hyg_279____closed__8; LEAN_EXPORT lean_object* l_Lean_ConstantInfo_numLevelParams___boxed(lean_object*); LEAN_EXPORT lean_object* l_List_foldlM___at_Lean_Declaration_forExprM___spec__4___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*); @@ -199,7 +203,9 @@ LEAN_EXPORT lean_object* l_Lean_DefinitionSafety_noConfusion(lean_object*); static lean_object* l_Lean_instInhabitedInductiveType___closed__1; LEAN_EXPORT lean_object* l_Lean_Declaration_forExprM(lean_object*); LEAN_EXPORT lean_object* l_Lean_DefinitionVal_getSafetyEx___boxed(lean_object*); +LEAN_EXPORT lean_object* l_Lean_OpaqueVal_all___default___boxed(lean_object*); static lean_object* l_Lean_instReprDefinitionSafety___closed__1; +LEAN_EXPORT lean_object* l_Lean_OpaqueVal_all___default(lean_object*); LEAN_EXPORT uint8_t lean_axiom_val_is_unsafe(lean_object*); LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___at_Lean_Declaration_forExprM___spec__1___rarg___lambda__1(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_QuotKind_toCtorIdx___boxed(lean_object*); @@ -944,20 +950,44 @@ x_1 = l_Lean_instReprDefinitionSafety___closed__1; return x_1; } } +LEAN_EXPORT lean_object* l_Lean_DefinitionVal_all___default(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = lean_ctor_get(x_1, 0); +x_3 = lean_box(0); +lean_inc(x_2); +x_4 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_4, 0, x_2); +lean_ctor_set(x_4, 1, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_DefinitionVal_all___default___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_DefinitionVal_all___default(x_1); +lean_dec(x_1); +return x_2; +} +} static lean_object* _init_l_Lean_instInhabitedDefinitionVal___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; -x_1 = l_Lean_instInhabitedConstantVal___closed__3; -x_2 = l_Lean_instInhabitedConstantVal___closed__2; -x_3 = lean_box(0); -x_4 = 0; -x_5 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_5, 0, x_1); -lean_ctor_set(x_5, 1, x_2); -lean_ctor_set(x_5, 2, x_3); -lean_ctor_set_uint8(x_5, sizeof(void*)*3, x_4); -return x_5; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; uint8_t x_5; lean_object* x_6; +x_1 = lean_box(0); +x_2 = l_Lean_instInhabitedConstantVal___closed__3; +x_3 = l_Lean_instInhabitedConstantVal___closed__2; +x_4 = lean_box(0); +x_5 = 0; +x_6 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_6, 0, x_2); +lean_ctor_set(x_6, 1, x_3); +lean_ctor_set(x_6, 2, x_4); +lean_ctor_set(x_6, 3, x_1); +lean_ctor_set_uint8(x_6, sizeof(void*)*4, x_5); +return x_6; } } static lean_object* _init_l_Lean_instInhabitedDefinitionVal() { @@ -968,37 +998,38 @@ x_1 = l_Lean_instInhabitedDefinitionVal___closed__1; return x_1; } } -LEAN_EXPORT lean_object* lean_mk_definition_val(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6) { +LEAN_EXPORT lean_object* lean_mk_definition_val(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, uint8_t x_6, lean_object* x_7) { _start: { -lean_object* x_7; lean_object* x_8; -x_7 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_7, 0, x_1); -lean_ctor_set(x_7, 1, x_2); -lean_ctor_set(x_7, 2, x_3); -x_8 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_8, 0, x_7); -lean_ctor_set(x_8, 1, x_4); -lean_ctor_set(x_8, 2, x_5); -lean_ctor_set_uint8(x_8, sizeof(void*)*3, x_6); -return x_8; +lean_object* x_8; lean_object* x_9; +x_8 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_8, 0, x_1); +lean_ctor_set(x_8, 1, x_2); +lean_ctor_set(x_8, 2, x_3); +x_9 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_9, 0, x_8); +lean_ctor_set(x_9, 1, x_4); +lean_ctor_set(x_9, 2, x_5); +lean_ctor_set(x_9, 3, x_7); +lean_ctor_set_uint8(x_9, sizeof(void*)*4, x_6); +return x_9; } } -LEAN_EXPORT lean_object* l_Lean_mkDefinitionValEx___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { +LEAN_EXPORT lean_object* l_Lean_mkDefinitionValEx___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7) { _start: { -uint8_t x_7; lean_object* x_8; -x_7 = lean_unbox(x_6); +uint8_t x_8; lean_object* x_9; +x_8 = lean_unbox(x_6); lean_dec(x_6); -x_8 = lean_mk_definition_val(x_1, x_2, x_3, x_4, x_5, x_7); -return x_8; +x_9 = lean_mk_definition_val(x_1, x_2, x_3, x_4, x_5, x_8, x_7); +return x_9; } } LEAN_EXPORT uint8_t lean_definition_val_get_safety(lean_object* x_1) { _start: { uint8_t x_2; -x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*3); +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*4); lean_dec(x_1); return x_2; } @@ -1012,16 +1043,40 @@ x_3 = lean_box(x_2); return x_3; } } +LEAN_EXPORT lean_object* l_Lean_TheoremVal_all___default(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = lean_ctor_get(x_1, 0); +x_3 = lean_box(0); +lean_inc(x_2); +x_4 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_4, 0, x_2); +lean_ctor_set(x_4, 1, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_TheoremVal_all___default___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_TheoremVal_all___default(x_1); +lean_dec(x_1); +return x_2; +} +} static lean_object* _init_l_Lean_instInhabitedTheoremVal___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_instInhabitedConstantVal___closed__3; -x_2 = l_Lean_instInhabitedConstantVal___closed__2; -x_3 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_3, 0, x_1); -lean_ctor_set(x_3, 1, x_2); -return x_3; +lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_1 = lean_box(0); +x_2 = l_Lean_instInhabitedConstantVal___closed__3; +x_3 = l_Lean_instInhabitedConstantVal___closed__2; +x_4 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_4, 0, x_2); +lean_ctor_set(x_4, 1, x_3); +lean_ctor_set(x_4, 2, x_1); +return x_4; } } static lean_object* _init_l_Lean_instInhabitedTheoremVal() { @@ -1032,18 +1087,42 @@ x_1 = l_Lean_instInhabitedTheoremVal___closed__1; return x_1; } } +LEAN_EXPORT lean_object* l_Lean_OpaqueVal_all___default(lean_object* x_1) { +_start: +{ +lean_object* x_2; lean_object* x_3; lean_object* x_4; +x_2 = lean_ctor_get(x_1, 0); +x_3 = lean_box(0); +lean_inc(x_2); +x_4 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_4, 0, x_2); +lean_ctor_set(x_4, 1, x_3); +return x_4; +} +} +LEAN_EXPORT lean_object* l_Lean_OpaqueVal_all___default___boxed(lean_object* x_1) { +_start: +{ +lean_object* x_2; +x_2 = l_Lean_OpaqueVal_all___default(x_1); +lean_dec(x_1); +return x_2; +} +} static lean_object* _init_l_Lean_instInhabitedOpaqueVal___closed__1() { _start: { -lean_object* x_1; lean_object* x_2; uint8_t x_3; lean_object* x_4; -x_1 = l_Lean_instInhabitedConstantVal___closed__3; -x_2 = l_Lean_instInhabitedConstantVal___closed__2; -x_3 = 0; -x_4 = lean_alloc_ctor(0, 2, 1); -lean_ctor_set(x_4, 0, x_1); -lean_ctor_set(x_4, 1, x_2); -lean_ctor_set_uint8(x_4, sizeof(void*)*2, x_3); -return x_4; +lean_object* x_1; lean_object* x_2; lean_object* x_3; uint8_t x_4; lean_object* x_5; +x_1 = lean_box(0); +x_2 = l_Lean_instInhabitedConstantVal___closed__3; +x_3 = l_Lean_instInhabitedConstantVal___closed__2; +x_4 = 0; +x_5 = lean_alloc_ctor(0, 3, 1); +lean_ctor_set(x_5, 0, x_2); +lean_ctor_set(x_5, 1, x_3); +lean_ctor_set(x_5, 2, x_1); +lean_ctor_set_uint8(x_5, sizeof(void*)*3, x_4); +return x_5; } } static lean_object* _init_l_Lean_instInhabitedOpaqueVal() { @@ -1054,36 +1133,37 @@ x_1 = l_Lean_instInhabitedOpaqueVal___closed__1; return x_1; } } -LEAN_EXPORT lean_object* lean_mk_opaque_val(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5) { +LEAN_EXPORT lean_object* lean_mk_opaque_val(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, uint8_t x_5, lean_object* x_6) { _start: { -lean_object* x_6; lean_object* x_7; -x_6 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_6, 0, x_1); -lean_ctor_set(x_6, 1, x_2); -lean_ctor_set(x_6, 2, x_3); -x_7 = lean_alloc_ctor(0, 2, 1); -lean_ctor_set(x_7, 0, x_6); -lean_ctor_set(x_7, 1, x_4); -lean_ctor_set_uint8(x_7, sizeof(void*)*2, x_5); -return x_7; +lean_object* x_7; lean_object* x_8; +x_7 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_7, 0, x_1); +lean_ctor_set(x_7, 1, x_2); +lean_ctor_set(x_7, 2, x_3); +x_8 = lean_alloc_ctor(0, 3, 1); +lean_ctor_set(x_8, 0, x_7); +lean_ctor_set(x_8, 1, x_4); +lean_ctor_set(x_8, 2, x_6); +lean_ctor_set_uint8(x_8, sizeof(void*)*3, x_5); +return x_8; } } -LEAN_EXPORT lean_object* l_Lean_mkOpaqueValEx___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5) { +LEAN_EXPORT lean_object* l_Lean_mkOpaqueValEx___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: { -uint8_t x_6; lean_object* x_7; -x_6 = lean_unbox(x_5); +uint8_t x_7; lean_object* x_8; +x_7 = lean_unbox(x_5); lean_dec(x_5); -x_7 = lean_mk_opaque_val(x_1, x_2, x_3, x_4, x_6); -return x_7; +x_8 = lean_mk_opaque_val(x_1, x_2, x_3, x_4, x_7, x_6); +return x_8; } } LEAN_EXPORT uint8_t lean_opaque_val_is_unsafe(lean_object* x_1) { _start: { uint8_t x_2; -x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*2); +x_2 = lean_ctor_get_uint8(x_1, sizeof(void*)*3); lean_dec(x_1); return x_2; } @@ -2349,7 +2429,7 @@ case 1: { lean_object* x_4; uint8_t x_5; uint8_t x_6; uint8_t x_7; x_4 = lean_ctor_get(x_1, 0); -x_5 = lean_ctor_get_uint8(x_4, sizeof(void*)*3); +x_5 = lean_ctor_get_uint8(x_4, sizeof(void*)*4); x_6 = 0; x_7 = l___private_Lean_Declaration_0__Lean_beqDefinitionSafety____x40_Lean_Declaration___hyg_263_(x_5, x_6); return x_7; @@ -2358,7 +2438,7 @@ case 3: { lean_object* x_8; uint8_t x_9; x_8 = lean_ctor_get(x_1, 0); -x_9 = lean_ctor_get_uint8(x_8, sizeof(void*)*2); +x_9 = lean_ctor_get_uint8(x_8, sizeof(void*)*3); return x_9; } case 5: @@ -2588,7 +2668,7 @@ _start: lean_object* x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; lean_object* x_6; x_1 = l_Lean_ConstantInfo_value_x21___closed__1; x_2 = l_Lean_ConstantInfo_value_x21___closed__2; -x_3 = lean_unsigned_to_nat(391u); +x_3 = lean_unsigned_to_nat(398u); x_4 = lean_unsigned_to_nat(33u); x_5 = l_Lean_ConstantInfo_value_x21___closed__3; x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); diff --git a/stage0/stdlib/Lean/Elab/Binders.c b/stage0/stdlib/Lean/Elab/Binders.c index 3988acc3ad..5e9e0d62ce 100644 --- a/stage0/stdlib/Lean/Elab/Binders.c +++ b/stage0/stdlib/Lean/Elab/Binders.c @@ -22,7 +22,6 @@ static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetFunDecl_declRange___clo LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabBinder___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_mkFreshFVarId___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_FunBinders_elabFunBinderViews___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabBinders(lean_object*); -static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__2; LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_matchBinder___spec__5(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_mkFreshBinderName___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandBinderIdent___spec__2___rarg___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Syntax_isAntiquotSuffixSplice(lean_object*); @@ -40,7 +39,6 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabLetDecl(lean_object*, lean_object* lean_object* l_List_forM___at___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___spec__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandBinderIdent___closed__4; static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__3; -static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__1; static lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandMatchAltsIntoMatchAux___closed__7; lean_object* l_Lean_registerTraceClass(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_addTermInfo_x27(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -99,6 +97,7 @@ static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDelayedDecl_declRange__ static lean_object* l_Lean_Elab_Term_elabArrow___closed__2; LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabLetDeclAux___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandMatchAltsIntoMatchAux___closed__3; +static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__1; LEAN_EXPORT lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandOptIdent___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabBinder___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandOptIdent___closed__1; @@ -107,6 +106,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabLetDeclAux___lambda__6___boxed(lea lean_object* lean_array_uset(lean_object*, size_t, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabFun(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDelayedDecl___closed__5; +static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__2; static lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow___closed__2; static lean_object* l___regBuiltin_Lean_Elab_Term_elabForall___closed__4; LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabBindersEx___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -173,6 +173,7 @@ lean_object* lean_expr_instantiate1(lean_object*, lean_object*); lean_object* l_Array_toSubarray___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); lean_object* lean_array_get_size(lean_object*); +static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__4; LEAN_EXPORT lean_object* l_Lean_Elab_Term_expandLetEqnsDecl(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabLetDelayedDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__53; @@ -186,7 +187,6 @@ lean_object* l_Lean_Meta_isClass_x3f(lean_object*, lean_object*, lean_object*, l LEAN_EXPORT lean_object* l___regBuiltin_Lean_Elab_Term_elabFun(lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow___closed__3; static lean_object* l___regBuiltin_Lean_Elab_Term_expandFun___closed__1; -static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__4; static lean_object* l___regBuiltin_Lean_Elab_Term_expandFun___closed__2; LEAN_EXPORT lean_object* l_Lean_mkFreshId___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_FunBinders_elabFunBinderViews___spec__2___rarg(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_expandFunBinders_loop___spec__3(lean_object*, size_t, size_t, lean_object*); @@ -330,8 +330,8 @@ lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_expandFunBinders_loop___spec__4(lean_object*, size_t, size_t, lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetTmpDecl___closed__4; static lean_object* l___regBuiltin_Lean_Elab_Term_expandFun_declRange___closed__4; -LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_7231_(lean_object*); -LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435_(lean_object*); +LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_7233_(lean_object*); +LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437_(lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow___closed__4; LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabLetDeclAux___lambda__6(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__20; @@ -413,6 +413,7 @@ static lean_object* l___regBuiltin_Lean_Elab_Term_elabArrow___closed__3; LEAN_EXPORT lean_object* l_Lean_Elab_Term_declareTacticSyntax___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_expandFunBinders_loop___spec__6___boxed(lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__19; +static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__5; static lean_object* l_Lean_Elab_Term_declareTacticSyntax___lambda__2___closed__2; static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetTmpDecl___closed__2; LEAN_EXPORT lean_object* l_Lean_Elab_Term_elabBinders___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -463,7 +464,6 @@ static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__26; extern lean_object* l_Lean_Elab_Term_termElabAttribute; static lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow_declRange___closed__5; LEAN_EXPORT lean_object* l_Array_anyMUnsafe_any___at_Lean_Elab_Term_expandFunBinders_loop___spec__7(lean_object*, size_t, size_t, lean_object*, lean_object*); -static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__5; lean_object* l_Lean_mkAtomFrom(lean_object*, lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabDepArrow_declRange___closed__3; LEAN_EXPORT lean_object* l_Lean_Elab_Term_mkFreshIdent___at___private_Lean_Elab_Binders_0__Lean_Elab_Term_expandBinderIdent___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -515,7 +515,6 @@ lean_object* l_Lean_mkApp(lean_object*, lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDecl_declRange___closed__2; static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__35; static lean_object* l_Lean_Elab_Term_quoteAutoTactic___closed__39; -static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3; static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDelayedDecl_declRange___closed__7; lean_object* l_Lean_Syntax_getArgs(lean_object*); static lean_object* l___regBuiltin_Lean_Elab_Term_elabFun_declRange___closed__7; @@ -526,6 +525,7 @@ static lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_quoteAutoTactic lean_object* l_Lean_Syntax_getKind(lean_object*); static lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed__1; extern lean_object* l_Lean_Core_instMonadCoreM; +static lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3; lean_object* l_Lean_Meta_saveAndResetSynthInstanceCache___rarg(lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed__2; static lean_object* l___regBuiltin_Lean_Elab_Term_elabLetDecl_declRange___closed__4; @@ -2826,88 +2826,94 @@ return x_20; LEAN_EXPORT lean_object* l_Lean_Elab_Term_declareTacticSyntax___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { _start: { -lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; +lean_inc(x_2); lean_inc(x_1); x_13 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_13, 0, x_1); lean_ctor_set(x_13, 1, x_2); lean_ctor_set(x_13, 2, x_3); -x_14 = lean_box(0); -x_15 = 1; -x_16 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_16, 0, x_13); -lean_ctor_set(x_16, 1, x_4); -lean_ctor_set(x_16, 2, x_14); -lean_ctor_set_uint8(x_16, sizeof(void*)*3, x_15); -x_17 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_17, 0, x_16); +lean_inc(x_1); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_1); +lean_ctor_set(x_14, 1, x_2); +x_15 = lean_box(0); +x_16 = 1; +x_17 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_17, 0, x_13); +lean_ctor_set(x_17, 1, x_4); +lean_ctor_set(x_17, 2, x_15); +lean_ctor_set(x_17, 3, x_14); +lean_ctor_set_uint8(x_17, sizeof(void*)*4, x_16); +x_18 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_18, 0, x_17); lean_inc(x_11); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); -lean_inc(x_17); -x_18 = l_Lean_addDecl___at_Lean_Elab_Term_evalExpr___spec__2(x_17, x_6, x_7, x_8, x_9, x_10, x_11, x_12); -if (lean_obj_tag(x_18) == 0) +lean_inc(x_18); +x_19 = l_Lean_addDecl___at_Lean_Elab_Term_evalExpr___spec__2(x_18, x_6, x_7, x_8, x_9, x_10, x_11, x_12); +if (lean_obj_tag(x_19) == 0) { -lean_object* x_19; lean_object* x_20; -x_19 = lean_ctor_get(x_18, 1); -lean_inc(x_19); -lean_dec(x_18); -x_20 = l_Lean_compileDecl___at_Lean_Elab_Term_evalExpr___spec__5(x_17, x_6, x_7, x_8, x_9, x_10, x_11, x_19); -if (lean_obj_tag(x_20) == 0) +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +lean_dec(x_19); +x_21 = l_Lean_compileDecl___at_Lean_Elab_Term_evalExpr___spec__5(x_18, x_6, x_7, x_8, x_9, x_10, x_11, x_20); +if (lean_obj_tag(x_21) == 0) { -uint8_t x_21; -x_21 = !lean_is_exclusive(x_20); -if (x_21 == 0) +uint8_t x_22; +x_22 = !lean_is_exclusive(x_21); +if (x_22 == 0) { -lean_object* x_22; -x_22 = lean_ctor_get(x_20, 0); -lean_dec(x_22); -lean_ctor_set(x_20, 0, x_1); -return x_20; +lean_object* x_23; +x_23 = lean_ctor_get(x_21, 0); +lean_dec(x_23); +lean_ctor_set(x_21, 0, x_1); +return x_21; } else { -lean_object* x_23; lean_object* x_24; -x_23 = lean_ctor_get(x_20, 1); -lean_inc(x_23); -lean_dec(x_20); -x_24 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_24, 0, x_1); -lean_ctor_set(x_24, 1, x_23); -return x_24; +lean_object* x_24; lean_object* x_25; +x_24 = lean_ctor_get(x_21, 1); +lean_inc(x_24); +lean_dec(x_21); +x_25 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_25, 0, x_1); +lean_ctor_set(x_25, 1, x_24); +return x_25; } } else { -uint8_t x_25; +uint8_t x_26; lean_dec(x_1); -x_25 = !lean_is_exclusive(x_20); -if (x_25 == 0) +x_26 = !lean_is_exclusive(x_21); +if (x_26 == 0) { -return x_20; +return x_21; } else { -lean_object* x_26; lean_object* x_27; lean_object* x_28; -x_26 = lean_ctor_get(x_20, 0); -x_27 = lean_ctor_get(x_20, 1); +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_21, 0); +x_28 = lean_ctor_get(x_21, 1); +lean_inc(x_28); lean_inc(x_27); -lean_inc(x_26); -lean_dec(x_20); -x_28 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_28, 0, x_26); -lean_ctor_set(x_28, 1, x_27); -return x_28; +lean_dec(x_21); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +return x_29; } } } else { -uint8_t x_29; -lean_dec(x_17); +uint8_t x_30; +lean_dec(x_18); lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); @@ -2915,23 +2921,23 @@ lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_1); -x_29 = !lean_is_exclusive(x_18); -if (x_29 == 0) +x_30 = !lean_is_exclusive(x_19); +if (x_30 == 0) { -return x_18; +return x_19; } else { -lean_object* x_30; lean_object* x_31; lean_object* x_32; -x_30 = lean_ctor_get(x_18, 0); -x_31 = lean_ctor_get(x_18, 1); +lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_31 = lean_ctor_get(x_19, 0); +x_32 = lean_ctor_get(x_19, 1); +lean_inc(x_32); lean_inc(x_31); -lean_inc(x_30); -lean_dec(x_18); -x_32 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_32, 0, x_30); -lean_ctor_set(x_32, 1, x_31); -return x_32; +lean_dec(x_19); +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_32); +return x_33; } } } @@ -4987,7 +4993,7 @@ lean_dec(x_1); return x_10; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__1() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__1() { _start: { lean_object* x_1; @@ -4995,17 +5001,17 @@ x_1 = lean_mk_string_from_bytes("checkBinderAnnotations", 22); return x_1; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__2() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__1; +x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3() { _start: { lean_object* x_1; @@ -5013,7 +5019,7 @@ x_1 = lean_mk_string_from_bytes("", 0); return x_1; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__4() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__4() { _start: { lean_object* x_1; @@ -5021,13 +5027,13 @@ x_1 = lean_mk_string_from_bytes("check whether type is a class instance whenever return x_1; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__5() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__5() { _start: { uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; x_1 = 1; -x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3; -x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__4; +x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3; +x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__4; x_4 = lean_box(x_1); x_5 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_5, 0, x_4); @@ -5036,12 +5042,12 @@ lean_ctor_set(x_5, 2, x_3); return x_5; } } -LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435_(lean_object* x_1) { +LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437_(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__2; -x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__5; +x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__2; +x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__5; x_4 = l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_6____spec__1(x_2, x_3, x_1); return x_4; } @@ -26306,7 +26312,7 @@ static lean_object* _init_l_Lean_Elab_Term_elabLetDeclAux___closed__4() { _start: { lean_object* x_1; lean_object* x_2; -x_1 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3; +x_1 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3; x_2 = l_Lean_stringToMessageData(x_1); return x_2; } @@ -28030,7 +28036,7 @@ x_4 = l_Lean_addBuiltinDeclarationRanges(x_2, x_3, x_1); return x_4; } } -LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_7231_(lean_object* x_1) { +LEAN_EXPORT lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_7233_(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; @@ -28322,17 +28328,17 @@ l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed_ lean_mark_persistent(l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed__3); l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed__4 = _init_l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed__4(); lean_mark_persistent(l___private_Lean_Elab_Binders_0__Lean_Elab_Term_ensureAtomicBinderName___closed__4); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__1(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__1); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__2(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__2); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__3); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__4(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__4); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__5 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__5(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435____closed__5); -if (builtin) {res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1435_(lean_io_mk_world()); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__1(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__1); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__2(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__2); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__3); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__4(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__4); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__5 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__5(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437____closed__5); +if (builtin) {res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_1437_(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; l_Lean_Elab_Term_checkBinderAnnotations = lean_io_result_get_value(res); lean_mark_persistent(l_Lean_Elab_Term_checkBinderAnnotations); @@ -28814,7 +28820,7 @@ lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_elabLetTmpDecl_declRange___cl res = l___regBuiltin_Lean_Elab_Term_elabLetTmpDecl_declRange(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); -res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_7231_(lean_io_mk_world()); +res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Binders___hyg_7233_(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); return lean_io_result_mk_ok(lean_box(0)); diff --git a/stage0/stdlib/Lean/Elab/BuiltinCommand.c b/stage0/stdlib/Lean/Elab/BuiltinCommand.c index 9c393f5e6e..32955eea71 100644 --- a/stage0/stdlib/Lean/Elab/BuiltinCommand.c +++ b/stage0/stdlib/Lean/Elab/BuiltinCommand.c @@ -17043,118 +17043,86 @@ return x_3; LEAN_EXPORT lean_object* l_Lean_Elab_Command_elabEvalUnsafe___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { _start: { -lean_object* x_12; lean_object* x_13; uint8_t x_88; lean_object* x_89; -x_88 = 1; +lean_object* x_12; lean_object* x_13; uint8_t x_90; lean_object* x_91; +x_90 = 1; lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_89 = l_Lean_Elab_Term_elabTerm(x_3, x_4, x_88, x_88, x_5, x_6, x_7, x_8, x_9, x_10, x_11); -if (lean_obj_tag(x_89) == 0) +x_91 = l_Lean_Elab_Term_elabTerm(x_3, x_4, x_90, x_90, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_91) == 0) { -lean_object* x_90; lean_object* x_91; uint8_t x_92; lean_object* x_93; -x_90 = lean_ctor_get(x_89, 0); -lean_inc(x_90); -x_91 = lean_ctor_get(x_89, 1); -lean_inc(x_91); -lean_dec(x_89); -x_92 = 0; +lean_object* x_92; lean_object* x_93; uint8_t x_94; lean_object* x_95; +x_92 = lean_ctor_get(x_91, 0); +lean_inc(x_92); +x_93 = lean_ctor_get(x_91, 1); +lean_inc(x_93); +lean_dec(x_91); +x_94 = 0; lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_93 = l_Lean_Elab_Term_synthesizeSyntheticMVars(x_92, x_92, x_5, x_6, x_7, x_8, x_9, x_10, x_91); -if (lean_obj_tag(x_93) == 0) -{ -lean_object* x_94; lean_object* x_95; -x_94 = lean_ctor_get(x_93, 1); -lean_inc(x_94); -lean_dec(x_93); -lean_inc(x_10); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_90); -x_95 = l_Lean_Meta_isProp(x_90, x_7, x_8, x_9, x_10, x_94); +x_95 = l_Lean_Elab_Term_synthesizeSyntheticMVars(x_94, x_94, x_5, x_6, x_7, x_8, x_9, x_10, x_93); if (lean_obj_tag(x_95) == 0) { -lean_object* x_96; uint8_t x_97; -x_96 = lean_ctor_get(x_95, 0); +lean_object* x_96; lean_object* x_97; +x_96 = lean_ctor_get(x_95, 1); lean_inc(x_96); -x_97 = lean_unbox(x_96); -lean_dec(x_96); -if (x_97 == 0) -{ -lean_object* x_98; -x_98 = lean_ctor_get(x_95, 1); -lean_inc(x_98); -lean_dec(x_95); -x_12 = x_90; -x_13 = x_98; -goto block_87; -} -else -{ -lean_object* x_99; lean_object* x_100; -x_99 = lean_ctor_get(x_95, 1); -lean_inc(x_99); lean_dec(x_95); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); -x_100 = l_Lean_Meta_mkDecide(x_90, x_7, x_8, x_9, x_10, x_99); -if (lean_obj_tag(x_100) == 0) +lean_inc(x_92); +x_97 = l_Lean_Meta_isProp(x_92, x_7, x_8, x_9, x_10, x_96); +if (lean_obj_tag(x_97) == 0) +{ +lean_object* x_98; uint8_t x_99; +x_98 = lean_ctor_get(x_97, 0); +lean_inc(x_98); +x_99 = lean_unbox(x_98); +lean_dec(x_98); +if (x_99 == 0) +{ +lean_object* x_100; +x_100 = lean_ctor_get(x_97, 1); +lean_inc(x_100); +lean_dec(x_97); +x_12 = x_92; +x_13 = x_100; +goto block_89; +} +else { lean_object* x_101; lean_object* x_102; -x_101 = lean_ctor_get(x_100, 0); +x_101 = lean_ctor_get(x_97, 1); lean_inc(x_101); -x_102 = lean_ctor_get(x_100, 1); -lean_inc(x_102); -lean_dec(x_100); -x_12 = x_101; -x_13 = x_102; -goto block_87; -} -else +lean_dec(x_97); +lean_inc(x_10); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +x_102 = l_Lean_Meta_mkDecide(x_92, x_7, x_8, x_9, x_10, x_101); +if (lean_obj_tag(x_102) == 0) { -uint8_t x_103; -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_2); -x_103 = !lean_is_exclusive(x_100); -if (x_103 == 0) -{ -return x_100; -} -else -{ -lean_object* x_104; lean_object* x_105; lean_object* x_106; -x_104 = lean_ctor_get(x_100, 0); -x_105 = lean_ctor_get(x_100, 1); -lean_inc(x_105); +lean_object* x_103; lean_object* x_104; +x_103 = lean_ctor_get(x_102, 0); +lean_inc(x_103); +x_104 = lean_ctor_get(x_102, 1); lean_inc(x_104); -lean_dec(x_100); -x_106 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_106, 0, x_104); -lean_ctor_set(x_106, 1, x_105); -return x_106; -} -} -} +lean_dec(x_102); +x_12 = x_103; +x_13 = x_104; +goto block_89; } else { -uint8_t x_107; -lean_dec(x_90); +uint8_t x_105; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -17162,30 +17130,92 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); -x_107 = !lean_is_exclusive(x_95); -if (x_107 == 0) +x_105 = !lean_is_exclusive(x_102); +if (x_105 == 0) +{ +return x_102; +} +else +{ +lean_object* x_106; lean_object* x_107; lean_object* x_108; +x_106 = lean_ctor_get(x_102, 0); +x_107 = lean_ctor_get(x_102, 1); +lean_inc(x_107); +lean_inc(x_106); +lean_dec(x_102); +x_108 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_108, 0, x_106); +lean_ctor_set(x_108, 1, x_107); +return x_108; +} +} +} +} +else +{ +uint8_t x_109; +lean_dec(x_92); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +x_109 = !lean_is_exclusive(x_97); +if (x_109 == 0) +{ +return x_97; +} +else +{ +lean_object* x_110; lean_object* x_111; lean_object* x_112; +x_110 = lean_ctor_get(x_97, 0); +x_111 = lean_ctor_get(x_97, 1); +lean_inc(x_111); +lean_inc(x_110); +lean_dec(x_97); +x_112 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_112, 0, x_110); +lean_ctor_set(x_112, 1, x_111); +return x_112; +} +} +} +else +{ +uint8_t x_113; +lean_dec(x_92); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +x_113 = !lean_is_exclusive(x_95); +if (x_113 == 0) { return x_95; } else { -lean_object* x_108; lean_object* x_109; lean_object* x_110; -x_108 = lean_ctor_get(x_95, 0); -x_109 = lean_ctor_get(x_95, 1); -lean_inc(x_109); -lean_inc(x_108); +lean_object* x_114; lean_object* x_115; lean_object* x_116; +x_114 = lean_ctor_get(x_95, 0); +x_115 = lean_ctor_get(x_95, 1); +lean_inc(x_115); +lean_inc(x_114); lean_dec(x_95); -x_110 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_110, 0, x_108); -lean_ctor_set(x_110, 1, x_109); -return x_110; +x_116 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_116, 0, x_114); +lean_ctor_set(x_116, 1, x_115); +return x_116; } } } else { -uint8_t x_111; -lean_dec(x_90); +uint8_t x_117; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -17193,56 +17223,26 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); -x_111 = !lean_is_exclusive(x_93); -if (x_111 == 0) +x_117 = !lean_is_exclusive(x_91); +if (x_117 == 0) { -return x_93; +return x_91; } else { -lean_object* x_112; lean_object* x_113; lean_object* x_114; -x_112 = lean_ctor_get(x_93, 0); -x_113 = lean_ctor_get(x_93, 1); -lean_inc(x_113); -lean_inc(x_112); -lean_dec(x_93); -x_114 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_114, 0, x_112); -lean_ctor_set(x_114, 1, x_113); -return x_114; +lean_object* x_118; lean_object* x_119; lean_object* x_120; +x_118 = lean_ctor_get(x_91, 0); +x_119 = lean_ctor_get(x_91, 1); +lean_inc(x_119); +lean_inc(x_118); +lean_dec(x_91); +x_120 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_120, 0, x_118); +lean_ctor_set(x_120, 1, x_119); +return x_120; } } -} -else -{ -uint8_t x_115; -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_2); -x_115 = !lean_is_exclusive(x_89); -if (x_115 == 0) -{ -return x_89; -} -else -{ -lean_object* x_116; lean_object* x_117; lean_object* x_118; -x_116 = lean_ctor_get(x_89, 0); -x_117 = lean_ctor_get(x_89, 1); -lean_inc(x_117); -lean_inc(x_116); -lean_dec(x_89); -x_118 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_118, 0, x_116); -lean_ctor_set(x_118, 1, x_117); -return x_118; -} -} -block_87: +block_89: { lean_object* x_14; lean_inc(x_10); @@ -17293,249 +17293,255 @@ lean_inc(x_29); x_30 = lean_infer_type(x_29, x_7, x_8, x_9, x_10, x_28); if (lean_obj_tag(x_30) == 0) { -lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; uint8_t x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; x_31 = lean_ctor_get(x_30, 0); lean_inc(x_31); x_32 = lean_ctor_get(x_30, 1); lean_inc(x_32); lean_dec(x_30); -x_33 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__2___closed__2; +x_33 = lean_box(0); +x_34 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__2___closed__2; lean_inc(x_29); -x_34 = l_Lean_CollectLevelParams_main(x_29, x_33); -x_35 = lean_ctor_get(x_34, 2); -lean_inc(x_35); -lean_dec(x_34); +x_35 = l_Lean_CollectLevelParams_main(x_29, x_34); +x_36 = lean_ctor_get(x_35, 2); +lean_inc(x_36); +lean_dec(x_35); lean_inc(x_8); -x_36 = l_Lean_Meta_instantiateMVars(x_29, x_7, x_8, x_9, x_10, x_32); -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); -x_38 = lean_ctor_get(x_36, 1); +x_37 = l_Lean_Meta_instantiateMVars(x_29, x_7, x_8, x_9, x_10, x_32); +x_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); -lean_dec(x_36); -x_39 = lean_array_to_list(lean_box(0), x_35); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_array_to_list(lean_box(0), x_36); lean_inc(x_2); -x_40 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_40, 0, x_2); -lean_ctor_set(x_40, 1, x_39); -lean_ctor_set(x_40, 2, x_31); -x_41 = lean_box(0); -x_42 = 0; -x_43 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_43, 0, x_40); -lean_ctor_set(x_43, 1, x_37); -lean_ctor_set(x_43, 2, x_41); -lean_ctor_set_uint8(x_43, sizeof(void*)*3, x_42); -x_44 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_44, 0, x_43); +x_41 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_41, 0, x_2); +lean_ctor_set(x_41, 1, x_40); +lean_ctor_set(x_41, 2, x_31); +lean_inc(x_2); +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_2); +lean_ctor_set(x_42, 1, x_33); +x_43 = lean_box(0); +x_44 = 0; +x_45 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_45, 0, x_41); +lean_ctor_set(x_45, 1, x_38); +lean_ctor_set(x_45, 2, x_43); +lean_ctor_set(x_45, 3, x_42); +lean_ctor_set_uint8(x_45, sizeof(void*)*4, x_44); +x_46 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_46, 0, x_45); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_44); -x_45 = l_Lean_Elab_Term_ensureNoUnassignedMVars(x_44, x_5, x_6, x_7, x_8, x_9, x_10, x_38); -if (lean_obj_tag(x_45) == 0) -{ -lean_object* x_46; lean_object* x_47; -x_46 = lean_ctor_get(x_45, 1); lean_inc(x_46); -lean_dec(x_45); -lean_inc(x_10); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_6); -lean_inc(x_5); -x_47 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_44, x_5, x_6, x_7, x_8, x_9, x_10, x_46); +x_47 = l_Lean_Elab_Term_ensureNoUnassignedMVars(x_46, x_5, x_6, x_7, x_8, x_9, x_10, x_39); if (lean_obj_tag(x_47) == 0) { lean_object* x_48; lean_object* x_49; x_48 = lean_ctor_get(x_47, 1); lean_inc(x_48); lean_dec(x_47); +lean_inc(x_10); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); lean_inc(x_5); -x_49 = l_Lean_evalConst___at_Lean_Elab_Term_evalExpr___spec__11___rarg(x_2, x_5, x_6, x_7, x_8, x_9, x_10, x_48); +x_49 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_46, x_5, x_6, x_7, x_8, x_9, x_10, x_48); if (lean_obj_tag(x_49) == 0) { -lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; -x_50 = lean_ctor_get(x_49, 0); +lean_object* x_50; lean_object* x_51; +x_50 = lean_ctor_get(x_49, 1); lean_inc(x_50); -x_51 = lean_ctor_get(x_49, 1); -lean_inc(x_51); lean_dec(x_49); -x_52 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_51); -x_53 = lean_ctor_get(x_52, 1); +lean_inc(x_5); +x_51 = l_Lean_evalConst___at_Lean_Elab_Term_evalExpr___spec__11___rarg(x_2, x_5, x_6, x_7, x_8, x_9, x_10, x_50); +if (lean_obj_tag(x_51) == 0) +{ +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_52 = lean_ctor_get(x_51, 0); +lean_inc(x_52); +x_53 = lean_ctor_get(x_51, 1); lean_inc(x_53); -lean_dec(x_52); -x_54 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__1(x_1, x_50, x_5, x_6, x_7, x_8, x_9, x_10, x_53); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -return x_54; -} -else -{ -lean_object* x_55; lean_object* x_56; lean_object* x_57; uint8_t x_58; -x_55 = lean_ctor_get(x_49, 0); +lean_dec(x_51); +x_54 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_53); +x_55 = lean_ctor_get(x_54, 1); lean_inc(x_55); -x_56 = lean_ctor_get(x_49, 1); -lean_inc(x_56); -lean_dec(x_49); -x_57 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_56); +lean_dec(x_54); +x_56 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__1(x_1, x_52, x_5, x_6, x_7, x_8, x_9, x_10, x_55); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +return x_56; +} +else +{ +lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_57 = lean_ctor_get(x_51, 0); +lean_inc(x_57); +x_58 = lean_ctor_get(x_51, 1); +lean_inc(x_58); +lean_dec(x_51); +x_59 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_58); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_58 = !lean_is_exclusive(x_57); -if (x_58 == 0) +x_60 = !lean_is_exclusive(x_59); +if (x_60 == 0) { -lean_object* x_59; -x_59 = lean_ctor_get(x_57, 0); -lean_dec(x_59); -lean_ctor_set_tag(x_57, 1); -lean_ctor_set(x_57, 0, x_55); -return x_57; +lean_object* x_61; +x_61 = lean_ctor_get(x_59, 0); +lean_dec(x_61); +lean_ctor_set_tag(x_59, 1); +lean_ctor_set(x_59, 0, x_57); +return x_59; } else { -lean_object* x_60; lean_object* x_61; -x_60 = lean_ctor_get(x_57, 1); -lean_inc(x_60); -lean_dec(x_57); -x_61 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_61, 0, x_55); -lean_ctor_set(x_61, 1, x_60); -return x_61; -} -} -} -else -{ -lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; -lean_dec(x_2); -x_62 = lean_ctor_get(x_47, 0); +lean_object* x_62; lean_object* x_63; +x_62 = lean_ctor_get(x_59, 1); lean_inc(x_62); -x_63 = lean_ctor_get(x_47, 1); -lean_inc(x_63); -lean_dec(x_47); -x_64 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_63); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -x_65 = !lean_is_exclusive(x_64); -if (x_65 == 0) -{ -lean_object* x_66; -x_66 = lean_ctor_get(x_64, 0); -lean_dec(x_66); -lean_ctor_set_tag(x_64, 1); -lean_ctor_set(x_64, 0, x_62); -return x_64; -} -else -{ -lean_object* x_67; lean_object* x_68; -x_67 = lean_ctor_get(x_64, 1); -lean_inc(x_67); -lean_dec(x_64); -x_68 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_68, 0, x_62); -lean_ctor_set(x_68, 1, x_67); -return x_68; +lean_dec(x_59); +x_63 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_63, 0, x_57); +lean_ctor_set(x_63, 1, x_62); +return x_63; } } } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; uint8_t x_72; -lean_dec(x_44); +lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_dec(x_2); -x_69 = lean_ctor_get(x_45, 0); -lean_inc(x_69); -x_70 = lean_ctor_get(x_45, 1); -lean_inc(x_70); -lean_dec(x_45); -x_71 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_70); +x_64 = lean_ctor_get(x_49, 0); +lean_inc(x_64); +x_65 = lean_ctor_get(x_49, 1); +lean_inc(x_65); +lean_dec(x_49); +x_66 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_65); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_72 = !lean_is_exclusive(x_71); -if (x_72 == 0) +x_67 = !lean_is_exclusive(x_66); +if (x_67 == 0) { -lean_object* x_73; -x_73 = lean_ctor_get(x_71, 0); +lean_object* x_68; +x_68 = lean_ctor_get(x_66, 0); +lean_dec(x_68); +lean_ctor_set_tag(x_66, 1); +lean_ctor_set(x_66, 0, x_64); +return x_66; +} +else +{ +lean_object* x_69; lean_object* x_70; +x_69 = lean_ctor_get(x_66, 1); +lean_inc(x_69); +lean_dec(x_66); +x_70 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_70, 0, x_64); +lean_ctor_set(x_70, 1, x_69); +return x_70; +} +} +} +else +{ +lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; +lean_dec(x_46); +lean_dec(x_2); +x_71 = lean_ctor_get(x_47, 0); +lean_inc(x_71); +x_72 = lean_ctor_get(x_47, 1); +lean_inc(x_72); +lean_dec(x_47); +x_73 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_72); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_74 = !lean_is_exclusive(x_73); +if (x_74 == 0) +{ +lean_object* x_75; +x_75 = lean_ctor_get(x_73, 0); +lean_dec(x_75); +lean_ctor_set_tag(x_73, 1); +lean_ctor_set(x_73, 0, x_71); +return x_73; +} +else +{ +lean_object* x_76; lean_object* x_77; +x_76 = lean_ctor_get(x_73, 1); +lean_inc(x_76); lean_dec(x_73); -lean_ctor_set_tag(x_71, 1); -lean_ctor_set(x_71, 0, x_69); -return x_71; -} -else -{ -lean_object* x_74; lean_object* x_75; -x_74 = lean_ctor_get(x_71, 1); -lean_inc(x_74); -lean_dec(x_71); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_69); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_77 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_77, 0, x_71); +lean_ctor_set(x_77, 1, x_76); +return x_77; } } } else { -lean_object* x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; +lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; lean_dec(x_29); lean_dec(x_2); -x_76 = lean_ctor_get(x_30, 0); -lean_inc(x_76); -x_77 = lean_ctor_get(x_30, 1); -lean_inc(x_77); +x_78 = lean_ctor_get(x_30, 0); +lean_inc(x_78); +x_79 = lean_ctor_get(x_30, 1); +lean_inc(x_79); lean_dec(x_30); -x_78 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_77); +x_80 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_79); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_79 = !lean_is_exclusive(x_78); -if (x_79 == 0) +x_81 = !lean_is_exclusive(x_80); +if (x_81 == 0) { -lean_object* x_80; -x_80 = lean_ctor_get(x_78, 0); +lean_object* x_82; +x_82 = lean_ctor_get(x_80, 0); +lean_dec(x_82); +lean_ctor_set_tag(x_80, 1); +lean_ctor_set(x_80, 0, x_78); +return x_80; +} +else +{ +lean_object* x_83; lean_object* x_84; +x_83 = lean_ctor_get(x_80, 1); +lean_inc(x_83); lean_dec(x_80); -lean_ctor_set_tag(x_78, 1); -lean_ctor_set(x_78, 0, x_76); -return x_78; -} -else -{ -lean_object* x_81; lean_object* x_82; -x_81 = lean_ctor_get(x_78, 1); -lean_inc(x_81); -lean_dec(x_78); -x_82 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_82, 0, x_76); -lean_ctor_set(x_82, 1, x_81); -return x_82; +x_84 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_84, 0, x_78); +lean_ctor_set(x_84, 1, x_83); +return x_84; } } } else { -uint8_t x_83; +uint8_t x_85; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -17543,23 +17549,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); -x_83 = !lean_is_exclusive(x_14); -if (x_83 == 0) +x_85 = !lean_is_exclusive(x_14); +if (x_85 == 0) { return x_14; } else { -lean_object* x_84; lean_object* x_85; lean_object* x_86; -x_84 = lean_ctor_get(x_14, 0); -x_85 = lean_ctor_get(x_14, 1); -lean_inc(x_85); -lean_inc(x_84); +lean_object* x_86; lean_object* x_87; lean_object* x_88; +x_86 = lean_ctor_get(x_14, 0); +x_87 = lean_ctor_get(x_14, 1); +lean_inc(x_87); +lean_inc(x_86); lean_dec(x_14); -x_86 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_86, 0, x_84); -lean_ctor_set(x_86, 1, x_85); -return x_86; +x_88 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_88, 0, x_86); +lean_ctor_set(x_88, 1, x_87); +return x_88; } } } @@ -17857,119 +17863,86 @@ return x_51; LEAN_EXPORT lean_object* l_Lean_Elab_Command_elabEvalUnsafe___lambda__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { _start: { -lean_object* x_12; lean_object* x_13; uint8_t x_89; lean_object* x_90; -x_89 = 1; +lean_object* x_12; lean_object* x_13; uint8_t x_91; lean_object* x_92; +x_91 = 1; lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_90 = l_Lean_Elab_Term_elabTerm(x_3, x_4, x_89, x_89, x_5, x_6, x_7, x_8, x_9, x_10, x_11); -if (lean_obj_tag(x_90) == 0) +x_92 = l_Lean_Elab_Term_elabTerm(x_3, x_4, x_91, x_91, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_92) == 0) { -lean_object* x_91; lean_object* x_92; uint8_t x_93; lean_object* x_94; -x_91 = lean_ctor_get(x_90, 0); -lean_inc(x_91); -x_92 = lean_ctor_get(x_90, 1); -lean_inc(x_92); -lean_dec(x_90); -x_93 = 0; +lean_object* x_93; lean_object* x_94; uint8_t x_95; lean_object* x_96; +x_93 = lean_ctor_get(x_92, 0); +lean_inc(x_93); +x_94 = lean_ctor_get(x_92, 1); +lean_inc(x_94); +lean_dec(x_92); +x_95 = 0; lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_94 = l_Lean_Elab_Term_synthesizeSyntheticMVars(x_93, x_93, x_5, x_6, x_7, x_8, x_9, x_10, x_92); -if (lean_obj_tag(x_94) == 0) -{ -lean_object* x_95; lean_object* x_96; -x_95 = lean_ctor_get(x_94, 1); -lean_inc(x_95); -lean_dec(x_94); -lean_inc(x_10); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_91); -x_96 = l_Lean_Meta_isProp(x_91, x_7, x_8, x_9, x_10, x_95); +x_96 = l_Lean_Elab_Term_synthesizeSyntheticMVars(x_95, x_95, x_5, x_6, x_7, x_8, x_9, x_10, x_94); if (lean_obj_tag(x_96) == 0) { -lean_object* x_97; uint8_t x_98; -x_97 = lean_ctor_get(x_96, 0); +lean_object* x_97; lean_object* x_98; +x_97 = lean_ctor_get(x_96, 1); lean_inc(x_97); -x_98 = lean_unbox(x_97); -lean_dec(x_97); -if (x_98 == 0) -{ -lean_object* x_99; -x_99 = lean_ctor_get(x_96, 1); -lean_inc(x_99); -lean_dec(x_96); -x_12 = x_91; -x_13 = x_99; -goto block_88; -} -else -{ -lean_object* x_100; lean_object* x_101; -x_100 = lean_ctor_get(x_96, 1); -lean_inc(x_100); lean_dec(x_96); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); -x_101 = l_Lean_Meta_mkDecide(x_91, x_7, x_8, x_9, x_10, x_100); -if (lean_obj_tag(x_101) == 0) +lean_inc(x_93); +x_98 = l_Lean_Meta_isProp(x_93, x_7, x_8, x_9, x_10, x_97); +if (lean_obj_tag(x_98) == 0) +{ +lean_object* x_99; uint8_t x_100; +x_99 = lean_ctor_get(x_98, 0); +lean_inc(x_99); +x_100 = lean_unbox(x_99); +lean_dec(x_99); +if (x_100 == 0) +{ +lean_object* x_101; +x_101 = lean_ctor_get(x_98, 1); +lean_inc(x_101); +lean_dec(x_98); +x_12 = x_93; +x_13 = x_101; +goto block_90; +} +else { lean_object* x_102; lean_object* x_103; -x_102 = lean_ctor_get(x_101, 0); +x_102 = lean_ctor_get(x_98, 1); lean_inc(x_102); -x_103 = lean_ctor_get(x_101, 1); -lean_inc(x_103); -lean_dec(x_101); -x_12 = x_102; -x_13 = x_103; -goto block_88; -} -else +lean_dec(x_98); +lean_inc(x_10); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +x_103 = l_Lean_Meta_mkDecide(x_93, x_7, x_8, x_9, x_10, x_102); +if (lean_obj_tag(x_103) == 0) { -uint8_t x_104; -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_2); -lean_dec(x_1); -x_104 = !lean_is_exclusive(x_101); -if (x_104 == 0) -{ -return x_101; -} -else -{ -lean_object* x_105; lean_object* x_106; lean_object* x_107; -x_105 = lean_ctor_get(x_101, 0); -x_106 = lean_ctor_get(x_101, 1); -lean_inc(x_106); +lean_object* x_104; lean_object* x_105; +x_104 = lean_ctor_get(x_103, 0); +lean_inc(x_104); +x_105 = lean_ctor_get(x_103, 1); lean_inc(x_105); -lean_dec(x_101); -x_107 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_107, 0, x_105); -lean_ctor_set(x_107, 1, x_106); -return x_107; -} -} -} +lean_dec(x_103); +x_12 = x_104; +x_13 = x_105; +goto block_90; } else { -uint8_t x_108; -lean_dec(x_91); +uint8_t x_106; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -17978,30 +17951,94 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_108 = !lean_is_exclusive(x_96); -if (x_108 == 0) +x_106 = !lean_is_exclusive(x_103); +if (x_106 == 0) +{ +return x_103; +} +else +{ +lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_107 = lean_ctor_get(x_103, 0); +x_108 = lean_ctor_get(x_103, 1); +lean_inc(x_108); +lean_inc(x_107); +lean_dec(x_103); +x_109 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_109, 0, x_107); +lean_ctor_set(x_109, 1, x_108); +return x_109; +} +} +} +} +else +{ +uint8_t x_110; +lean_dec(x_93); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +lean_dec(x_1); +x_110 = !lean_is_exclusive(x_98); +if (x_110 == 0) +{ +return x_98; +} +else +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; +x_111 = lean_ctor_get(x_98, 0); +x_112 = lean_ctor_get(x_98, 1); +lean_inc(x_112); +lean_inc(x_111); +lean_dec(x_98); +x_113 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_113, 0, x_111); +lean_ctor_set(x_113, 1, x_112); +return x_113; +} +} +} +else +{ +uint8_t x_114; +lean_dec(x_93); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_2); +lean_dec(x_1); +x_114 = !lean_is_exclusive(x_96); +if (x_114 == 0) { return x_96; } else { -lean_object* x_109; lean_object* x_110; lean_object* x_111; -x_109 = lean_ctor_get(x_96, 0); -x_110 = lean_ctor_get(x_96, 1); -lean_inc(x_110); -lean_inc(x_109); +lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_115 = lean_ctor_get(x_96, 0); +x_116 = lean_ctor_get(x_96, 1); +lean_inc(x_116); +lean_inc(x_115); lean_dec(x_96); -x_111 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_111, 0, x_109); -lean_ctor_set(x_111, 1, x_110); -return x_111; +x_117 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_117, 0, x_115); +lean_ctor_set(x_117, 1, x_116); +return x_117; } } } else { -uint8_t x_112; -lean_dec(x_91); +uint8_t x_118; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -18010,57 +18047,26 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_112 = !lean_is_exclusive(x_94); -if (x_112 == 0) +x_118 = !lean_is_exclusive(x_92); +if (x_118 == 0) { -return x_94; +return x_92; } else { -lean_object* x_113; lean_object* x_114; lean_object* x_115; -x_113 = lean_ctor_get(x_94, 0); -x_114 = lean_ctor_get(x_94, 1); -lean_inc(x_114); -lean_inc(x_113); -lean_dec(x_94); -x_115 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_115, 0, x_113); -lean_ctor_set(x_115, 1, x_114); -return x_115; +lean_object* x_119; lean_object* x_120; lean_object* x_121; +x_119 = lean_ctor_get(x_92, 0); +x_120 = lean_ctor_get(x_92, 1); +lean_inc(x_120); +lean_inc(x_119); +lean_dec(x_92); +x_121 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_121, 0, x_119); +lean_ctor_set(x_121, 1, x_120); +return x_121; } } -} -else -{ -uint8_t x_116; -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_2); -lean_dec(x_1); -x_116 = !lean_is_exclusive(x_90); -if (x_116 == 0) -{ -return x_90; -} -else -{ -lean_object* x_117; lean_object* x_118; lean_object* x_119; -x_117 = lean_ctor_get(x_90, 0); -x_118 = lean_ctor_get(x_90, 1); -lean_inc(x_118); -lean_inc(x_117); -lean_dec(x_90); -x_119 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_119, 0, x_117); -lean_ctor_set(x_119, 1, x_118); -return x_119; -} -} -block_88: +block_90: { lean_object* x_14; lean_inc(x_10); @@ -18113,259 +18119,265 @@ lean_inc(x_30); x_31 = lean_infer_type(x_30, x_7, x_8, x_9, x_10, x_29); if (lean_obj_tag(x_31) == 0) { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; x_32 = lean_ctor_get(x_31, 0); lean_inc(x_32); x_33 = lean_ctor_get(x_31, 1); lean_inc(x_33); lean_dec(x_31); -x_34 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__2___closed__2; +x_34 = lean_box(0); +x_35 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__2___closed__2; lean_inc(x_30); -x_35 = l_Lean_CollectLevelParams_main(x_30, x_34); -x_36 = lean_ctor_get(x_35, 2); -lean_inc(x_36); -lean_dec(x_35); +x_36 = l_Lean_CollectLevelParams_main(x_30, x_35); +x_37 = lean_ctor_get(x_36, 2); +lean_inc(x_37); +lean_dec(x_36); lean_inc(x_8); -x_37 = l_Lean_Meta_instantiateMVars(x_30, x_7, x_8, x_9, x_10, x_33); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -x_39 = lean_ctor_get(x_37, 1); +x_38 = l_Lean_Meta_instantiateMVars(x_30, x_7, x_8, x_9, x_10, x_33); +x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -lean_dec(x_37); -x_40 = lean_array_to_list(lean_box(0), x_36); +x_40 = lean_ctor_get(x_38, 1); +lean_inc(x_40); +lean_dec(x_38); +x_41 = lean_array_to_list(lean_box(0), x_37); lean_inc(x_2); -x_41 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_41, 0, x_2); -lean_ctor_set(x_41, 1, x_40); -lean_ctor_set(x_41, 2, x_32); -x_42 = lean_box(0); -x_43 = 0; -x_44 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_44, 0, x_41); -lean_ctor_set(x_44, 1, x_38); -lean_ctor_set(x_44, 2, x_42); -lean_ctor_set_uint8(x_44, sizeof(void*)*3, x_43); -x_45 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_45, 0, x_44); +x_42 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_42, 0, x_2); +lean_ctor_set(x_42, 1, x_41); +lean_ctor_set(x_42, 2, x_32); +lean_inc(x_2); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_2); +lean_ctor_set(x_43, 1, x_34); +x_44 = lean_box(0); +x_45 = 0; +x_46 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_46, 0, x_42); +lean_ctor_set(x_46, 1, x_39); +lean_ctor_set(x_46, 2, x_44); +lean_ctor_set(x_46, 3, x_43); +lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_45); +x_47 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_47, 0, x_46); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_45); -x_46 = l_Lean_Elab_Term_ensureNoUnassignedMVars(x_45, x_5, x_6, x_7, x_8, x_9, x_10, x_39); -if (lean_obj_tag(x_46) == 0) -{ -lean_object* x_47; lean_object* x_48; -x_47 = lean_ctor_get(x_46, 1); lean_inc(x_47); -lean_dec(x_46); -lean_inc(x_10); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_6); -lean_inc(x_5); -x_48 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_45, x_5, x_6, x_7, x_8, x_9, x_10, x_47); +x_48 = l_Lean_Elab_Term_ensureNoUnassignedMVars(x_47, x_5, x_6, x_7, x_8, x_9, x_10, x_40); if (lean_obj_tag(x_48) == 0) { lean_object* x_49; lean_object* x_50; x_49 = lean_ctor_get(x_48, 1); lean_inc(x_49); lean_dec(x_48); +lean_inc(x_10); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); lean_inc(x_5); -x_50 = l_Lean_evalConst___at_Lean_Elab_Term_evalExpr___spec__11___rarg(x_2, x_5, x_6, x_7, x_8, x_9, x_10, x_49); +x_50 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_47, x_5, x_6, x_7, x_8, x_9, x_10, x_49); if (lean_obj_tag(x_50) == 0) { -lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_51 = lean_ctor_get(x_50, 0); +lean_object* x_51; lean_object* x_52; +x_51 = lean_ctor_get(x_50, 1); lean_inc(x_51); -x_52 = lean_ctor_get(x_50, 1); -lean_inc(x_52); lean_dec(x_50); -lean_inc(x_20); -x_53 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_52); -x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_5); +x_52 = l_Lean_evalConst___at_Lean_Elab_Term_evalExpr___spec__11___rarg(x_2, x_5, x_6, x_7, x_8, x_9, x_10, x_51); +if (lean_obj_tag(x_52) == 0) +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_53 = lean_ctor_get(x_52, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_52, 1); lean_inc(x_54); -lean_dec(x_53); -x_55 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__5(x_20, x_21, x_1, x_51, x_5, x_6, x_7, x_8, x_9, x_10, x_54); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_1); -return x_55; -} -else -{ -lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; -lean_dec(x_21); -lean_dec(x_1); -x_56 = lean_ctor_get(x_50, 0); +lean_dec(x_52); +lean_inc(x_20); +x_55 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_54); +x_56 = lean_ctor_get(x_55, 1); lean_inc(x_56); -x_57 = lean_ctor_get(x_50, 1); -lean_inc(x_57); -lean_dec(x_50); -x_58 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_57); +lean_dec(x_55); +x_57 = l_Lean_Elab_Command_elabEvalUnsafe___lambda__5(x_20, x_21, x_1, x_53, x_5, x_6, x_7, x_8, x_9, x_10, x_56); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +return x_57; +} +else +{ +lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; +lean_dec(x_21); +lean_dec(x_1); +x_58 = lean_ctor_get(x_52, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_52, 1); +lean_inc(x_59); +lean_dec(x_52); +x_60 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_59); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_59 = !lean_is_exclusive(x_58); -if (x_59 == 0) +x_61 = !lean_is_exclusive(x_60); +if (x_61 == 0) { -lean_object* x_60; -x_60 = lean_ctor_get(x_58, 0); -lean_dec(x_60); -lean_ctor_set_tag(x_58, 1); -lean_ctor_set(x_58, 0, x_56); -return x_58; +lean_object* x_62; +x_62 = lean_ctor_get(x_60, 0); +lean_dec(x_62); +lean_ctor_set_tag(x_60, 1); +lean_ctor_set(x_60, 0, x_58); +return x_60; } else { -lean_object* x_61; lean_object* x_62; -x_61 = lean_ctor_get(x_58, 1); -lean_inc(x_61); -lean_dec(x_58); -x_62 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_62, 0, x_56); -lean_ctor_set(x_62, 1, x_61); -return x_62; -} -} -} -else -{ -lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; -lean_dec(x_21); -lean_dec(x_2); -lean_dec(x_1); -x_63 = lean_ctor_get(x_48, 0); +lean_object* x_63; lean_object* x_64; +x_63 = lean_ctor_get(x_60, 1); lean_inc(x_63); -x_64 = lean_ctor_get(x_48, 1); -lean_inc(x_64); -lean_dec(x_48); -x_65 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_64); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -x_66 = !lean_is_exclusive(x_65); -if (x_66 == 0) -{ -lean_object* x_67; -x_67 = lean_ctor_get(x_65, 0); -lean_dec(x_67); -lean_ctor_set_tag(x_65, 1); -lean_ctor_set(x_65, 0, x_63); -return x_65; -} -else -{ -lean_object* x_68; lean_object* x_69; -x_68 = lean_ctor_get(x_65, 1); -lean_inc(x_68); -lean_dec(x_65); -x_69 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_69, 0, x_63); -lean_ctor_set(x_69, 1, x_68); -return x_69; +lean_dec(x_60); +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_58); +lean_ctor_set(x_64, 1, x_63); +return x_64; } } } else { -lean_object* x_70; lean_object* x_71; lean_object* x_72; uint8_t x_73; -lean_dec(x_45); +lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_dec(x_21); lean_dec(x_2); lean_dec(x_1); -x_70 = lean_ctor_get(x_46, 0); -lean_inc(x_70); -x_71 = lean_ctor_get(x_46, 1); -lean_inc(x_71); -lean_dec(x_46); -x_72 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_71); +x_65 = lean_ctor_get(x_50, 0); +lean_inc(x_65); +x_66 = lean_ctor_get(x_50, 1); +lean_inc(x_66); +lean_dec(x_50); +x_67 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_66); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_73 = !lean_is_exclusive(x_72); -if (x_73 == 0) +x_68 = !lean_is_exclusive(x_67); +if (x_68 == 0) { -lean_object* x_74; -x_74 = lean_ctor_get(x_72, 0); +lean_object* x_69; +x_69 = lean_ctor_get(x_67, 0); +lean_dec(x_69); +lean_ctor_set_tag(x_67, 1); +lean_ctor_set(x_67, 0, x_65); +return x_67; +} +else +{ +lean_object* x_70; lean_object* x_71; +x_70 = lean_ctor_get(x_67, 1); +lean_inc(x_70); +lean_dec(x_67); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_65); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} +} +else +{ +lean_object* x_72; lean_object* x_73; lean_object* x_74; uint8_t x_75; +lean_dec(x_47); +lean_dec(x_21); +lean_dec(x_2); +lean_dec(x_1); +x_72 = lean_ctor_get(x_48, 0); +lean_inc(x_72); +x_73 = lean_ctor_get(x_48, 1); +lean_inc(x_73); +lean_dec(x_48); +x_74 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_73); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +x_75 = !lean_is_exclusive(x_74); +if (x_75 == 0) +{ +lean_object* x_76; +x_76 = lean_ctor_get(x_74, 0); +lean_dec(x_76); +lean_ctor_set_tag(x_74, 1); +lean_ctor_set(x_74, 0, x_72); +return x_74; +} +else +{ +lean_object* x_77; lean_object* x_78; +x_77 = lean_ctor_get(x_74, 1); +lean_inc(x_77); lean_dec(x_74); -lean_ctor_set_tag(x_72, 1); -lean_ctor_set(x_72, 0, x_70); -return x_72; -} -else -{ -lean_object* x_75; lean_object* x_76; -x_75 = lean_ctor_get(x_72, 1); -lean_inc(x_75); -lean_dec(x_72); -x_76 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_76, 0, x_70); -lean_ctor_set(x_76, 1, x_75); -return x_76; +x_78 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_78, 0, x_72); +lean_ctor_set(x_78, 1, x_77); +return x_78; } } } else { -lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; +lean_object* x_79; lean_object* x_80; lean_object* x_81; uint8_t x_82; lean_dec(x_30); lean_dec(x_21); lean_dec(x_2); lean_dec(x_1); -x_77 = lean_ctor_get(x_31, 0); -lean_inc(x_77); -x_78 = lean_ctor_get(x_31, 1); -lean_inc(x_78); +x_79 = lean_ctor_get(x_31, 0); +lean_inc(x_79); +x_80 = lean_ctor_get(x_31, 1); +lean_inc(x_80); lean_dec(x_31); -x_79 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_78); +x_81 = l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(x_20, x_5, x_6, x_7, x_8, x_9, x_10, x_80); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_80 = !lean_is_exclusive(x_79); -if (x_80 == 0) +x_82 = !lean_is_exclusive(x_81); +if (x_82 == 0) { -lean_object* x_81; -x_81 = lean_ctor_get(x_79, 0); +lean_object* x_83; +x_83 = lean_ctor_get(x_81, 0); +lean_dec(x_83); +lean_ctor_set_tag(x_81, 1); +lean_ctor_set(x_81, 0, x_79); +return x_81; +} +else +{ +lean_object* x_84; lean_object* x_85; +x_84 = lean_ctor_get(x_81, 1); +lean_inc(x_84); lean_dec(x_81); -lean_ctor_set_tag(x_79, 1); -lean_ctor_set(x_79, 0, x_77); -return x_79; -} -else -{ -lean_object* x_82; lean_object* x_83; -x_82 = lean_ctor_get(x_79, 1); -lean_inc(x_82); -lean_dec(x_79); -x_83 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_83, 0, x_77); -lean_ctor_set(x_83, 1, x_82); -return x_83; +x_85 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_85, 0, x_79); +lean_ctor_set(x_85, 1, x_84); +return x_85; } } } else { -uint8_t x_84; +uint8_t x_86; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -18374,23 +18386,23 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_84 = !lean_is_exclusive(x_14); -if (x_84 == 0) +x_86 = !lean_is_exclusive(x_14); +if (x_86 == 0) { return x_14; } else { -lean_object* x_85; lean_object* x_86; lean_object* x_87; -x_85 = lean_ctor_get(x_14, 0); -x_86 = lean_ctor_get(x_14, 1); -lean_inc(x_86); -lean_inc(x_85); +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_14, 0); +x_88 = lean_ctor_get(x_14, 1); +lean_inc(x_88); +lean_inc(x_87); lean_dec(x_14); -x_87 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_87, 0, x_85); -lean_ctor_set(x_87, 1, x_86); -return x_87; +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +return x_89; } } } diff --git a/stage0/stdlib/Lean/Elab/Deriving/DecEq.c b/stage0/stdlib/Lean/Elab/Deriving/DecEq.c index 3e73d31a8c..6a44ab87d2 100644 --- a/stage0/stdlib/Lean/Elab/Deriving/DecEq.c +++ b/stage0/stdlib/Lean/Elab/Deriving/DecEq.c @@ -7122,7 +7122,7 @@ x_23 = 1; x_24 = l_Lean_Meta_mkLambdaFVars(x_17, x_20, x_21, x_22, x_23, x_7, x_8, x_9, x_10, x_11); if (lean_obj_tag(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; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -7136,25 +7136,31 @@ lean_inc(x_29); lean_dec(x_27); x_30 = l_Lean_Elab_Deriving_DecEq_mkEnumOfNat___lambda__1___closed__3; x_31 = lean_name_mk_string(x_5, x_30); +lean_inc(x_1); +lean_inc(x_31); x_32 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_32, 0, x_31); lean_ctor_set(x_32, 1, x_1); lean_ctor_set(x_32, 2, x_28); -x_33 = lean_box(1); -x_34 = 1; -x_35 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_35, 0, x_32); -lean_ctor_set(x_35, 1, x_25); -lean_ctor_set(x_35, 2, x_33); -lean_ctor_set_uint8(x_35, sizeof(void*)*3, x_34); -x_36 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_36, 0, x_35); -x_37 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_36, x_7, x_8, x_9, x_10, x_29); -return x_37; +x_33 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_33, 0, x_31); +lean_ctor_set(x_33, 1, x_1); +x_34 = lean_box(1); +x_35 = 1; +x_36 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_36, 0, x_32); +lean_ctor_set(x_36, 1, x_25); +lean_ctor_set(x_36, 2, x_34); +lean_ctor_set(x_36, 3, x_33); +lean_ctor_set_uint8(x_36, sizeof(void*)*4, x_35); +x_37 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_37, 0, x_36); +x_38 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_37, x_7, x_8, x_9, x_10, x_29); +return x_38; } else { -uint8_t x_38; +uint8_t x_39; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -7163,23 +7169,23 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_1); -x_38 = !lean_is_exclusive(x_24); -if (x_38 == 0) +x_39 = !lean_is_exclusive(x_24); +if (x_39 == 0) { return x_24; } else { -lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_39 = lean_ctor_get(x_24, 0); -x_40 = lean_ctor_get(x_24, 1); +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_24, 0); +x_41 = lean_ctor_get(x_24, 1); +lean_inc(x_41); lean_inc(x_40); -lean_inc(x_39); lean_dec(x_24); -x_41 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_41, 0, x_39); -lean_ctor_set(x_41, 1, x_40); -return x_41; +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +return x_42; } } } @@ -7364,7 +7370,7 @@ lean_dec(x_34); x_37 = l_Lean_Meta_mkForallFVars(x_18, x_16, x_19, x_20, x_21, x_9, x_10, x_11, x_12, x_36); if (lean_obj_tag(x_37) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; +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_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); x_39 = lean_ctor_get(x_37, 1); @@ -7372,21 +7378,27 @@ lean_inc(x_39); lean_dec(x_37); x_40 = l_Lean_Elab_Deriving_DecEq_mkEnumOfNatThm___lambda__1___closed__1; x_41 = lean_name_mk_string(x_4, x_40); +lean_inc(x_5); +lean_inc(x_41); x_42 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_42, 0, x_41); lean_ctor_set(x_42, 1, x_5); lean_ctor_set(x_42, 2, x_38); -x_43 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_43, 0, x_42); -lean_ctor_set(x_43, 1, x_35); -x_44 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_44, 0, x_43); -x_45 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_44, x_9, x_10, x_11, x_12, x_39); -return x_45; +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_5); +x_44 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_35); +lean_ctor_set(x_44, 2, x_43); +x_45 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_45, 0, x_44); +x_46 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_45, x_9, x_10, x_11, x_12, x_39); +return x_46; } else { -uint8_t x_46; +uint8_t x_47; lean_dec(x_35); lean_dec(x_12); lean_dec(x_11); @@ -7394,29 +7406,29 @@ lean_dec(x_10); lean_dec(x_9); lean_dec(x_5); lean_dec(x_4); -x_46 = !lean_is_exclusive(x_37); -if (x_46 == 0) +x_47 = !lean_is_exclusive(x_37); +if (x_47 == 0) { return x_37; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -x_47 = lean_ctor_get(x_37, 0); -x_48 = lean_ctor_get(x_37, 1); +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_37, 0); +x_49 = lean_ctor_get(x_37, 1); +lean_inc(x_49); lean_inc(x_48); -lean_inc(x_47); lean_dec(x_37); -x_49 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_49, 0, x_47); -lean_ctor_set(x_49, 1, x_48); -return x_49; +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_48); +lean_ctor_set(x_50, 1, x_49); +return x_50; } } } else { -uint8_t x_50; +uint8_t x_51; lean_dec(x_18); lean_dec(x_16); lean_dec(x_12); @@ -7425,29 +7437,29 @@ lean_dec(x_10); lean_dec(x_9); lean_dec(x_5); lean_dec(x_4); -x_50 = !lean_is_exclusive(x_34); -if (x_50 == 0) +x_51 = !lean_is_exclusive(x_34); +if (x_51 == 0) { return x_34; } else { -lean_object* x_51; lean_object* x_52; lean_object* x_53; -x_51 = lean_ctor_get(x_34, 0); -x_52 = lean_ctor_get(x_34, 1); +lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_34, 0); +x_53 = lean_ctor_get(x_34, 1); +lean_inc(x_53); lean_inc(x_52); -lean_inc(x_51); lean_dec(x_34); -x_53 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_53, 0, x_51); -lean_ctor_set(x_53, 1, x_52); -return x_53; +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +return x_54; } } } else { -uint8_t x_54; +uint8_t x_55; lean_dec(x_18); lean_dec(x_16); lean_dec(x_12); @@ -7459,23 +7471,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -x_54 = !lean_is_exclusive(x_22); -if (x_54 == 0) +x_55 = !lean_is_exclusive(x_22); +if (x_55 == 0) { return x_22; } else { -lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_55 = lean_ctor_get(x_22, 0); -x_56 = lean_ctor_get(x_22, 1); +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_22, 0); +x_57 = lean_ctor_get(x_22, 1); +lean_inc(x_57); lean_inc(x_56); -lean_inc(x_55); lean_dec(x_22); -x_57 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_57, 0, x_55); -lean_ctor_set(x_57, 1, x_56); -return x_57; +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set(x_58, 1, x_57); +return x_58; } } } diff --git a/stage0/stdlib/Lean/Elab/MutualDef.c b/stage0/stdlib/Lean/Elab/MutualDef.c index e4816a2ba7..c3c7a8f8ef 100644 --- a/stage0/stdlib/Lean/Elab/MutualDef.c +++ b/stage0/stdlib/Lean/Elab/MutualDef.c @@ -25574,24 +25574,26 @@ lean_dec(x_10); x_14 = !lean_is_exclusive(x_12); if (x_14 == 0) { -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; x_15 = lean_ctor_get(x_12, 0); x_16 = lean_ctor_get(x_12, 1); x_17 = lean_ctor_get(x_12, 2); +x_18 = lean_ctor_get(x_12, 3); +lean_dec(x_18); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); lean_inc(x_1); -x_18 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_mkInst_x3f(x_1, x_16, x_5, x_6, x_7, x_8, x_13); -if (lean_obj_tag(x_18) == 0) -{ -lean_object* x_19; -x_19 = lean_ctor_get(x_18, 0); -lean_inc(x_19); +x_19 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_mkInst_x3f(x_1, x_16, x_5, x_6, x_7, x_8, x_13); if (lean_obj_tag(x_19) == 0) { -uint8_t x_20; +lean_object* x_20; +x_20 = lean_ctor_get(x_19, 0); +lean_inc(x_20); +if (lean_obj_tag(x_20) == 0) +{ +uint8_t x_21; lean_free_object(x_12); lean_dec(x_17); lean_dec(x_15); @@ -25603,225 +25605,230 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_20 = !lean_is_exclusive(x_18); -if (x_20 == 0) +x_21 = !lean_is_exclusive(x_19); +if (x_21 == 0) { -lean_object* x_21; uint8_t x_22; lean_object* x_23; -x_21 = lean_ctor_get(x_18, 0); -lean_dec(x_21); -x_22 = 0; -x_23 = lean_box(x_22); -lean_ctor_set(x_18, 0, x_23); -return x_18; +lean_object* x_22; uint8_t x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_19, 0); +lean_dec(x_22); +x_23 = 0; +x_24 = lean_box(x_23); +lean_ctor_set(x_19, 0, x_24); +return x_19; } else { -lean_object* x_24; uint8_t x_25; lean_object* x_26; lean_object* x_27; -x_24 = lean_ctor_get(x_18, 1); -lean_inc(x_24); -lean_dec(x_18); -x_25 = 0; -x_26 = lean_box(x_25); -x_27 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_27, 0, x_26); -lean_ctor_set(x_27, 1, x_24); -return x_27; +lean_object* x_25; uint8_t x_26; lean_object* x_27; lean_object* x_28; +x_25 = lean_ctor_get(x_19, 1); +lean_inc(x_25); +lean_dec(x_19); +x_26 = 0; +x_27 = lean_box(x_26); +x_28 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_28, 0, x_27); +lean_ctor_set(x_28, 1, x_25); +return x_28; } } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; -x_28 = lean_ctor_get(x_18, 1); -lean_inc(x_28); -lean_dec(x_18); -x_29 = lean_ctor_get(x_19, 0); +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; uint8_t x_33; +x_29 = lean_ctor_get(x_19, 1); lean_inc(x_29); lean_dec(x_19); -x_30 = lean_ctor_get(x_29, 1); +x_30 = lean_ctor_get(x_20, 0); lean_inc(x_30); -x_31 = l_Lean_Expr_appFn_x21(x_30); -lean_dec(x_30); -x_32 = !lean_is_exclusive(x_15); -if (x_32 == 0) +lean_dec(x_20); +x_31 = lean_ctor_get(x_30, 1); +lean_inc(x_31); +x_32 = l_Lean_Expr_appFn_x21(x_31); +lean_dec(x_31); +x_33 = !lean_is_exclusive(x_15); +if (x_33 == 0) { -lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -x_33 = lean_ctor_get(x_15, 1); -x_34 = lean_ctor_get(x_15, 2); -lean_dec(x_34); -x_35 = lean_ctor_get(x_15, 0); +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_34 = lean_ctor_get(x_15, 1); +x_35 = lean_ctor_get(x_15, 2); lean_dec(x_35); -x_36 = lean_box(0); -lean_inc(x_33); -x_37 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_33, x_36); +x_36 = lean_ctor_get(x_15, 0); +lean_dec(x_36); +x_37 = lean_box(0); +lean_inc(x_34); +x_38 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_34, x_37); lean_inc(x_2); -x_38 = l_Lean_mkConst(x_2, x_37); -x_39 = l_Lean_mkApp(x_31, x_38); +x_39 = l_Lean_mkConst(x_2, x_38); +x_40 = l_Lean_mkApp(x_32, x_39); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_39); -x_40 = l_Lean_Meta_check(x_39, x_5, x_6, x_7, x_8, x_28); -if (lean_obj_tag(x_40) == 0) +lean_inc(x_40); +x_41 = l_Lean_Meta_check(x_40, x_5, x_6, x_7, x_8, x_29); +if (lean_obj_tag(x_41) == 0) { -lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = l_Lean_Elab_Term_processDefDeriving___closed__1; -x_43 = lean_name_append_before(x_2, x_42); -x_44 = l_Lean_Name_getString_x21(x_1); -x_45 = lean_name_append_after(x_43, x_44); -x_46 = lean_alloc_closure((void*)(l_Lean_Elab_mkUnusedBaseName), 3, 1); -lean_closure_set(x_46, 0, x_45); +lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_42 = lean_ctor_get(x_41, 1); +lean_inc(x_42); +lean_dec(x_41); +x_43 = l_Lean_Elab_Term_processDefDeriving___closed__1; +x_44 = lean_name_append_before(x_2, x_43); +x_45 = l_Lean_Name_getString_x21(x_1); +x_46 = lean_name_append_after(x_44, x_45); +x_47 = lean_alloc_closure((void*)(l_Lean_Elab_mkUnusedBaseName), 3, 1); +lean_closure_set(x_47, 0, x_46); lean_inc(x_7); lean_inc(x_3); -x_47 = l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1(x_46, x_3, x_4, x_5, x_6, x_7, x_8, x_41); -if (lean_obj_tag(x_47) == 0) +x_48 = l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1(x_47, x_3, x_4, x_5, x_6, x_7, x_8, x_42); +if (lean_obj_tag(x_48) == 0) { -lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_49 = lean_ctor_get(x_48, 0); lean_inc(x_49); -lean_dec(x_47); +x_50 = lean_ctor_get(x_48, 1); +lean_inc(x_50); +lean_dec(x_48); lean_inc(x_6); -x_50 = l_Lean_Meta_instantiateMVars(x_39, x_5, x_6, x_7, x_8, x_49); -x_51 = lean_ctor_get(x_50, 0); -lean_inc(x_51); -x_52 = lean_ctor_get(x_50, 1); +x_51 = l_Lean_Meta_instantiateMVars(x_40, x_5, x_6, x_7, x_8, x_50); +x_52 = lean_ctor_get(x_51, 0); lean_inc(x_52); -lean_dec(x_50); -x_53 = lean_ctor_get(x_29, 0); +x_53 = lean_ctor_get(x_51, 1); lean_inc(x_53); -lean_dec(x_29); +lean_dec(x_51); +x_54 = lean_ctor_get(x_30, 0); +lean_inc(x_54); +lean_dec(x_30); lean_inc(x_6); -x_54 = l_Lean_Meta_instantiateMVars(x_53, x_5, x_6, x_7, x_8, x_52); -x_55 = lean_ctor_get(x_54, 0); -lean_inc(x_55); -x_56 = lean_ctor_get(x_54, 1); +x_55 = l_Lean_Meta_instantiateMVars(x_54, x_5, x_6, x_7, x_8, x_53); +x_56 = lean_ctor_get(x_55, 0); lean_inc(x_56); -lean_dec(x_54); -lean_inc(x_48); -lean_ctor_set(x_15, 2, x_51); -lean_ctor_set(x_15, 0, x_48); -lean_ctor_set(x_12, 1, x_55); -x_57 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_57, 0, x_12); +x_57 = lean_ctor_get(x_55, 1); +lean_inc(x_57); +lean_dec(x_55); +lean_inc(x_49); +lean_ctor_set(x_15, 2, x_52); +lean_ctor_set(x_15, 0, x_49); +lean_inc(x_49); +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_49); +lean_ctor_set(x_58, 1, x_37); +lean_ctor_set(x_12, 3, x_58); +lean_ctor_set(x_12, 1, x_56); +x_59 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_59, 0, x_12); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_58 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_57, x_3, x_4, x_5, x_6, x_7, x_8, x_56); -if (lean_obj_tag(x_58) == 0) +x_60 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_59, x_3, x_4, x_5, x_6, x_7, x_8, x_57); +if (lean_obj_tag(x_60) == 0) { -lean_object* x_59; uint8_t x_60; lean_object* x_61; lean_object* x_62; -x_59 = lean_ctor_get(x_58, 1); -lean_inc(x_59); -lean_dec(x_58); -x_60 = 0; -x_61 = lean_unsigned_to_nat(1000u); -x_62 = l_Lean_Meta_addInstance(x_48, x_60, x_61, x_5, x_6, x_7, x_8, x_59); -if (lean_obj_tag(x_62) == 0) +lean_object* x_61; uint8_t x_62; lean_object* x_63; lean_object* x_64; +x_61 = lean_ctor_get(x_60, 1); +lean_inc(x_61); +lean_dec(x_60); +x_62 = 0; +x_63 = lean_unsigned_to_nat(1000u); +x_64 = l_Lean_Meta_addInstance(x_49, x_62, x_63, x_5, x_6, x_7, x_8, x_61); +if (lean_obj_tag(x_64) == 0) { -uint8_t x_63; -x_63 = !lean_is_exclusive(x_62); -if (x_63 == 0) +uint8_t x_65; +x_65 = !lean_is_exclusive(x_64); +if (x_65 == 0) { -lean_object* x_64; uint8_t x_65; lean_object* x_66; -x_64 = lean_ctor_get(x_62, 0); +lean_object* x_66; uint8_t x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_64, 0); +lean_dec(x_66); +x_67 = 1; +x_68 = lean_box(x_67); +lean_ctor_set(x_64, 0, x_68); +return x_64; +} +else +{ +lean_object* x_69; uint8_t x_70; lean_object* x_71; lean_object* x_72; +x_69 = lean_ctor_get(x_64, 1); +lean_inc(x_69); lean_dec(x_64); -x_65 = 1; -x_66 = lean_box(x_65); -lean_ctor_set(x_62, 0, x_66); -return x_62; -} -else -{ -lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_70; -x_67 = lean_ctor_get(x_62, 1); -lean_inc(x_67); -lean_dec(x_62); -x_68 = 1; -x_69 = lean_box(x_68); -x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_69); -lean_ctor_set(x_70, 1, x_67); -return x_70; +x_70 = 1; +x_71 = lean_box(x_70); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_71); +lean_ctor_set(x_72, 1, x_69); +return x_72; } } else { -uint8_t x_71; -x_71 = !lean_is_exclusive(x_62); -if (x_71 == 0) +uint8_t x_73; +x_73 = !lean_is_exclusive(x_64); +if (x_73 == 0) { -lean_object* x_72; uint8_t x_73; lean_object* x_74; -x_72 = lean_ctor_get(x_62, 0); -lean_dec(x_72); -x_73 = 0; -x_74 = lean_box(x_73); -lean_ctor_set_tag(x_62, 0); -lean_ctor_set(x_62, 0, x_74); -return x_62; +lean_object* x_74; uint8_t x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_64, 0); +lean_dec(x_74); +x_75 = 0; +x_76 = lean_box(x_75); +lean_ctor_set_tag(x_64, 0); +lean_ctor_set(x_64, 0, x_76); +return x_64; } else { -lean_object* x_75; uint8_t x_76; lean_object* x_77; lean_object* x_78; -x_75 = lean_ctor_get(x_62, 1); -lean_inc(x_75); -lean_dec(x_62); -x_76 = 0; -x_77 = lean_box(x_76); -x_78 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_78, 0, x_77); -lean_ctor_set(x_78, 1, x_75); -return x_78; +lean_object* x_77; uint8_t x_78; lean_object* x_79; lean_object* x_80; +x_77 = lean_ctor_get(x_64, 1); +lean_inc(x_77); +lean_dec(x_64); +x_78 = 0; +x_79 = lean_box(x_78); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_79); +lean_ctor_set(x_80, 1, x_77); +return x_80; } } } else { -uint8_t x_79; -lean_dec(x_48); +uint8_t x_81; +lean_dec(x_49); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_79 = !lean_is_exclusive(x_58); -if (x_79 == 0) +x_81 = !lean_is_exclusive(x_60); +if (x_81 == 0) { -lean_object* x_80; uint8_t x_81; lean_object* x_82; -x_80 = lean_ctor_get(x_58, 0); -lean_dec(x_80); -x_81 = 0; -x_82 = lean_box(x_81); -lean_ctor_set_tag(x_58, 0); -lean_ctor_set(x_58, 0, x_82); -return x_58; +lean_object* x_82; uint8_t x_83; lean_object* x_84; +x_82 = lean_ctor_get(x_60, 0); +lean_dec(x_82); +x_83 = 0; +x_84 = lean_box(x_83); +lean_ctor_set_tag(x_60, 0); +lean_ctor_set(x_60, 0, x_84); +return x_60; } else { -lean_object* x_83; uint8_t x_84; lean_object* x_85; lean_object* x_86; -x_83 = lean_ctor_get(x_58, 1); -lean_inc(x_83); -lean_dec(x_58); -x_84 = 0; -x_85 = lean_box(x_84); -x_86 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_86, 0, x_85); -lean_ctor_set(x_86, 1, x_83); -return x_86; +lean_object* x_85; uint8_t x_86; lean_object* x_87; lean_object* x_88; +x_85 = lean_ctor_get(x_60, 1); +lean_inc(x_85); +lean_dec(x_60); +x_86 = 0; +x_87 = lean_box(x_86); +x_88 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_88, 0, x_87); +lean_ctor_set(x_88, 1, x_85); +return x_88; } } } else { -uint8_t x_87; -lean_dec(x_39); +uint8_t x_89; +lean_dec(x_40); lean_free_object(x_15); -lean_dec(x_33); -lean_dec(x_29); +lean_dec(x_34); +lean_dec(x_30); lean_free_object(x_12); lean_dec(x_17); lean_dec(x_8); @@ -25830,40 +25837,40 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_87 = !lean_is_exclusive(x_47); -if (x_87 == 0) +x_89 = !lean_is_exclusive(x_48); +if (x_89 == 0) { -lean_object* x_88; uint8_t x_89; lean_object* x_90; -x_88 = lean_ctor_get(x_47, 0); -lean_dec(x_88); -x_89 = 0; -x_90 = lean_box(x_89); -lean_ctor_set_tag(x_47, 0); -lean_ctor_set(x_47, 0, x_90); -return x_47; +lean_object* x_90; uint8_t x_91; lean_object* x_92; +x_90 = lean_ctor_get(x_48, 0); +lean_dec(x_90); +x_91 = 0; +x_92 = lean_box(x_91); +lean_ctor_set_tag(x_48, 0); +lean_ctor_set(x_48, 0, x_92); +return x_48; } else { -lean_object* x_91; uint8_t x_92; lean_object* x_93; lean_object* x_94; -x_91 = lean_ctor_get(x_47, 1); -lean_inc(x_91); -lean_dec(x_47); -x_92 = 0; -x_93 = lean_box(x_92); -x_94 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_94, 0, x_93); -lean_ctor_set(x_94, 1, x_91); -return x_94; +lean_object* x_93; uint8_t x_94; lean_object* x_95; lean_object* x_96; +x_93 = lean_ctor_get(x_48, 1); +lean_inc(x_93); +lean_dec(x_48); +x_94 = 0; +x_95 = lean_box(x_94); +x_96 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_96, 0, x_95); +lean_ctor_set(x_96, 1, x_93); +return x_96; } } } else { -uint8_t x_95; -lean_dec(x_39); +uint8_t x_97; +lean_dec(x_40); lean_free_object(x_15); -lean_dec(x_33); -lean_dec(x_29); +lean_dec(x_34); +lean_dec(x_30); lean_free_object(x_12); lean_dec(x_17); lean_dec(x_8); @@ -25874,201 +25881,206 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_95 = !lean_is_exclusive(x_40); -if (x_95 == 0) +x_97 = !lean_is_exclusive(x_41); +if (x_97 == 0) { -lean_object* x_96; uint8_t x_97; lean_object* x_98; -x_96 = lean_ctor_get(x_40, 0); -lean_dec(x_96); -x_97 = 0; -x_98 = lean_box(x_97); -lean_ctor_set_tag(x_40, 0); -lean_ctor_set(x_40, 0, x_98); -return x_40; +lean_object* x_98; uint8_t x_99; lean_object* x_100; +x_98 = lean_ctor_get(x_41, 0); +lean_dec(x_98); +x_99 = 0; +x_100 = lean_box(x_99); +lean_ctor_set_tag(x_41, 0); +lean_ctor_set(x_41, 0, x_100); +return x_41; } else { -lean_object* x_99; uint8_t x_100; lean_object* x_101; lean_object* x_102; -x_99 = lean_ctor_get(x_40, 1); -lean_inc(x_99); -lean_dec(x_40); -x_100 = 0; -x_101 = lean_box(x_100); -x_102 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_102, 0, x_101); -lean_ctor_set(x_102, 1, x_99); -return x_102; +lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_104; +x_101 = lean_ctor_get(x_41, 1); +lean_inc(x_101); +lean_dec(x_41); +x_102 = 0; +x_103 = lean_box(x_102); +x_104 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_104, 0, x_103); +lean_ctor_set(x_104, 1, x_101); +return x_104; } } } else { -lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; -x_103 = lean_ctor_get(x_15, 1); -lean_inc(x_103); +lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; +x_105 = lean_ctor_get(x_15, 1); +lean_inc(x_105); lean_dec(x_15); -x_104 = lean_box(0); -lean_inc(x_103); -x_105 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_103, x_104); +x_106 = lean_box(0); +lean_inc(x_105); +x_107 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_105, x_106); lean_inc(x_2); -x_106 = l_Lean_mkConst(x_2, x_105); -x_107 = l_Lean_mkApp(x_31, x_106); +x_108 = l_Lean_mkConst(x_2, x_107); +x_109 = l_Lean_mkApp(x_32, x_108); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_107); -x_108 = l_Lean_Meta_check(x_107, x_5, x_6, x_7, x_8, x_28); -if (lean_obj_tag(x_108) == 0) -{ -lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; -x_109 = lean_ctor_get(x_108, 1); lean_inc(x_109); -lean_dec(x_108); -x_110 = l_Lean_Elab_Term_processDefDeriving___closed__1; -x_111 = lean_name_append_before(x_2, x_110); -x_112 = l_Lean_Name_getString_x21(x_1); -x_113 = lean_name_append_after(x_111, x_112); -x_114 = lean_alloc_closure((void*)(l_Lean_Elab_mkUnusedBaseName), 3, 1); -lean_closure_set(x_114, 0, x_113); +x_110 = l_Lean_Meta_check(x_109, x_5, x_6, x_7, x_8, x_29); +if (lean_obj_tag(x_110) == 0) +{ +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; +x_111 = lean_ctor_get(x_110, 1); +lean_inc(x_111); +lean_dec(x_110); +x_112 = l_Lean_Elab_Term_processDefDeriving___closed__1; +x_113 = lean_name_append_before(x_2, x_112); +x_114 = l_Lean_Name_getString_x21(x_1); +x_115 = lean_name_append_after(x_113, x_114); +x_116 = lean_alloc_closure((void*)(l_Lean_Elab_mkUnusedBaseName), 3, 1); +lean_closure_set(x_116, 0, x_115); lean_inc(x_7); lean_inc(x_3); -x_115 = l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1(x_114, x_3, x_4, x_5, x_6, x_7, x_8, x_109); -if (lean_obj_tag(x_115) == 0) +x_117 = l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1(x_116, x_3, x_4, x_5, x_6, x_7, x_8, x_111); +if (lean_obj_tag(x_117) == 0) { -lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; -x_116 = lean_ctor_get(x_115, 0); -lean_inc(x_116); -x_117 = lean_ctor_get(x_115, 1); -lean_inc(x_117); -lean_dec(x_115); -lean_inc(x_6); -x_118 = l_Lean_Meta_instantiateMVars(x_107, x_5, x_6, x_7, x_8, x_117); -x_119 = lean_ctor_get(x_118, 0); +lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; +x_118 = lean_ctor_get(x_117, 0); +lean_inc(x_118); +x_119 = lean_ctor_get(x_117, 1); lean_inc(x_119); -x_120 = lean_ctor_get(x_118, 1); -lean_inc(x_120); -lean_dec(x_118); -x_121 = lean_ctor_get(x_29, 0); -lean_inc(x_121); -lean_dec(x_29); +lean_dec(x_117); lean_inc(x_6); -x_122 = l_Lean_Meta_instantiateMVars(x_121, x_5, x_6, x_7, x_8, x_120); -x_123 = lean_ctor_get(x_122, 0); +x_120 = l_Lean_Meta_instantiateMVars(x_109, x_5, x_6, x_7, x_8, x_119); +x_121 = lean_ctor_get(x_120, 0); +lean_inc(x_121); +x_122 = lean_ctor_get(x_120, 1); +lean_inc(x_122); +lean_dec(x_120); +x_123 = lean_ctor_get(x_30, 0); lean_inc(x_123); -x_124 = lean_ctor_get(x_122, 1); -lean_inc(x_124); -lean_dec(x_122); -lean_inc(x_116); -x_125 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_125, 0, x_116); -lean_ctor_set(x_125, 1, x_103); -lean_ctor_set(x_125, 2, x_119); -lean_ctor_set(x_12, 1, x_123); -lean_ctor_set(x_12, 0, x_125); -x_126 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_126, 0, x_12); +lean_dec(x_30); +lean_inc(x_6); +x_124 = l_Lean_Meta_instantiateMVars(x_123, x_5, x_6, x_7, x_8, x_122); +x_125 = lean_ctor_get(x_124, 0); +lean_inc(x_125); +x_126 = lean_ctor_get(x_124, 1); +lean_inc(x_126); +lean_dec(x_124); +lean_inc(x_118); +x_127 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_127, 0, x_118); +lean_ctor_set(x_127, 1, x_105); +lean_ctor_set(x_127, 2, x_121); +lean_inc(x_118); +x_128 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_128, 0, x_118); +lean_ctor_set(x_128, 1, x_106); +lean_ctor_set(x_12, 3, x_128); +lean_ctor_set(x_12, 1, x_125); +lean_ctor_set(x_12, 0, x_127); +x_129 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_129, 0, x_12); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_127 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_126, x_3, x_4, x_5, x_6, x_7, x_8, x_124); -if (lean_obj_tag(x_127) == 0) +x_130 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_129, x_3, x_4, x_5, x_6, x_7, x_8, x_126); +if (lean_obj_tag(x_130) == 0) { -lean_object* x_128; uint8_t x_129; lean_object* x_130; lean_object* x_131; -x_128 = lean_ctor_get(x_127, 1); -lean_inc(x_128); -lean_dec(x_127); -x_129 = 0; -x_130 = lean_unsigned_to_nat(1000u); -x_131 = l_Lean_Meta_addInstance(x_116, x_129, x_130, x_5, x_6, x_7, x_8, x_128); -if (lean_obj_tag(x_131) == 0) +lean_object* x_131; uint8_t x_132; lean_object* x_133; lean_object* x_134; +x_131 = lean_ctor_get(x_130, 1); +lean_inc(x_131); +lean_dec(x_130); +x_132 = 0; +x_133 = lean_unsigned_to_nat(1000u); +x_134 = l_Lean_Meta_addInstance(x_118, x_132, x_133, x_5, x_6, x_7, x_8, x_131); +if (lean_obj_tag(x_134) == 0) { -lean_object* x_132; lean_object* x_133; uint8_t x_134; lean_object* x_135; lean_object* x_136; -x_132 = lean_ctor_get(x_131, 1); -lean_inc(x_132); -if (lean_is_exclusive(x_131)) { - lean_ctor_release(x_131, 0); - lean_ctor_release(x_131, 1); - x_133 = x_131; +lean_object* x_135; lean_object* x_136; uint8_t x_137; lean_object* x_138; lean_object* x_139; +x_135 = lean_ctor_get(x_134, 1); +lean_inc(x_135); +if (lean_is_exclusive(x_134)) { + lean_ctor_release(x_134, 0); + lean_ctor_release(x_134, 1); + x_136 = x_134; } else { - lean_dec_ref(x_131); - x_133 = lean_box(0); + lean_dec_ref(x_134); + x_136 = lean_box(0); } -x_134 = 1; -x_135 = lean_box(x_134); -if (lean_is_scalar(x_133)) { - x_136 = lean_alloc_ctor(0, 2, 0); +x_137 = 1; +x_138 = lean_box(x_137); +if (lean_is_scalar(x_136)) { + x_139 = lean_alloc_ctor(0, 2, 0); } else { - x_136 = x_133; + x_139 = x_136; } -lean_ctor_set(x_136, 0, x_135); -lean_ctor_set(x_136, 1, x_132); -return x_136; +lean_ctor_set(x_139, 0, x_138); +lean_ctor_set(x_139, 1, x_135); +return x_139; } else { -lean_object* x_137; lean_object* x_138; uint8_t x_139; lean_object* x_140; lean_object* x_141; -x_137 = lean_ctor_get(x_131, 1); -lean_inc(x_137); -if (lean_is_exclusive(x_131)) { - lean_ctor_release(x_131, 0); - lean_ctor_release(x_131, 1); - x_138 = x_131; +lean_object* x_140; lean_object* x_141; uint8_t x_142; lean_object* x_143; lean_object* x_144; +x_140 = lean_ctor_get(x_134, 1); +lean_inc(x_140); +if (lean_is_exclusive(x_134)) { + lean_ctor_release(x_134, 0); + lean_ctor_release(x_134, 1); + x_141 = x_134; } else { - lean_dec_ref(x_131); - x_138 = lean_box(0); + lean_dec_ref(x_134); + x_141 = lean_box(0); } -x_139 = 0; -x_140 = lean_box(x_139); -if (lean_is_scalar(x_138)) { - x_141 = lean_alloc_ctor(0, 2, 0); +x_142 = 0; +x_143 = lean_box(x_142); +if (lean_is_scalar(x_141)) { + x_144 = lean_alloc_ctor(0, 2, 0); } else { - x_141 = x_138; - lean_ctor_set_tag(x_141, 0); + x_144 = x_141; + lean_ctor_set_tag(x_144, 0); } -lean_ctor_set(x_141, 0, x_140); -lean_ctor_set(x_141, 1, x_137); -return x_141; +lean_ctor_set(x_144, 0, x_143); +lean_ctor_set(x_144, 1, x_140); +return x_144; } } else { -lean_object* x_142; lean_object* x_143; uint8_t x_144; lean_object* x_145; lean_object* x_146; -lean_dec(x_116); +lean_object* x_145; lean_object* x_146; uint8_t x_147; lean_object* x_148; lean_object* x_149; +lean_dec(x_118); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_142 = lean_ctor_get(x_127, 1); -lean_inc(x_142); -if (lean_is_exclusive(x_127)) { - lean_ctor_release(x_127, 0); - lean_ctor_release(x_127, 1); - x_143 = x_127; +x_145 = lean_ctor_get(x_130, 1); +lean_inc(x_145); +if (lean_is_exclusive(x_130)) { + lean_ctor_release(x_130, 0); + lean_ctor_release(x_130, 1); + x_146 = x_130; } else { - lean_dec_ref(x_127); - x_143 = lean_box(0); + lean_dec_ref(x_130); + x_146 = lean_box(0); } -x_144 = 0; -x_145 = lean_box(x_144); -if (lean_is_scalar(x_143)) { - x_146 = lean_alloc_ctor(0, 2, 0); +x_147 = 0; +x_148 = lean_box(x_147); +if (lean_is_scalar(x_146)) { + x_149 = lean_alloc_ctor(0, 2, 0); } else { - x_146 = x_143; - lean_ctor_set_tag(x_146, 0); + x_149 = x_146; + lean_ctor_set_tag(x_149, 0); } -lean_ctor_set(x_146, 0, x_145); -lean_ctor_set(x_146, 1, x_142); -return x_146; +lean_ctor_set(x_149, 0, x_148); +lean_ctor_set(x_149, 1, x_145); +return x_149; } } else { -lean_object* x_147; lean_object* x_148; uint8_t x_149; lean_object* x_150; lean_object* x_151; -lean_dec(x_107); -lean_dec(x_103); -lean_dec(x_29); +lean_object* x_150; lean_object* x_151; uint8_t x_152; lean_object* x_153; lean_object* x_154; +lean_dec(x_109); +lean_dec(x_105); +lean_dec(x_30); lean_free_object(x_12); lean_dec(x_17); lean_dec(x_8); @@ -26077,35 +26089,35 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_147 = lean_ctor_get(x_115, 1); -lean_inc(x_147); -if (lean_is_exclusive(x_115)) { - lean_ctor_release(x_115, 0); - lean_ctor_release(x_115, 1); - x_148 = x_115; +x_150 = lean_ctor_get(x_117, 1); +lean_inc(x_150); +if (lean_is_exclusive(x_117)) { + lean_ctor_release(x_117, 0); + lean_ctor_release(x_117, 1); + x_151 = x_117; } else { - lean_dec_ref(x_115); - x_148 = lean_box(0); + lean_dec_ref(x_117); + x_151 = lean_box(0); } -x_149 = 0; -x_150 = lean_box(x_149); -if (lean_is_scalar(x_148)) { - x_151 = lean_alloc_ctor(0, 2, 0); +x_152 = 0; +x_153 = lean_box(x_152); +if (lean_is_scalar(x_151)) { + x_154 = lean_alloc_ctor(0, 2, 0); } else { - x_151 = x_148; - lean_ctor_set_tag(x_151, 0); + x_154 = x_151; + lean_ctor_set_tag(x_154, 0); } -lean_ctor_set(x_151, 0, x_150); -lean_ctor_set(x_151, 1, x_147); -return x_151; +lean_ctor_set(x_154, 0, x_153); +lean_ctor_set(x_154, 1, x_150); +return x_154; } } else { -lean_object* x_152; lean_object* x_153; uint8_t x_154; lean_object* x_155; lean_object* x_156; -lean_dec(x_107); -lean_dec(x_103); -lean_dec(x_29); +lean_object* x_155; lean_object* x_156; uint8_t x_157; lean_object* x_158; lean_object* x_159; +lean_dec(x_109); +lean_dec(x_105); +lean_dec(x_30); lean_free_object(x_12); lean_dec(x_17); lean_dec(x_8); @@ -26116,34 +26128,34 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_152 = lean_ctor_get(x_108, 1); -lean_inc(x_152); -if (lean_is_exclusive(x_108)) { - lean_ctor_release(x_108, 0); - lean_ctor_release(x_108, 1); - x_153 = x_108; +x_155 = lean_ctor_get(x_110, 1); +lean_inc(x_155); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + x_156 = x_110; } else { - lean_dec_ref(x_108); - x_153 = lean_box(0); + lean_dec_ref(x_110); + x_156 = lean_box(0); } -x_154 = 0; -x_155 = lean_box(x_154); -if (lean_is_scalar(x_153)) { - x_156 = lean_alloc_ctor(0, 2, 0); +x_157 = 0; +x_158 = lean_box(x_157); +if (lean_is_scalar(x_156)) { + x_159 = lean_alloc_ctor(0, 2, 0); } else { - x_156 = x_153; - lean_ctor_set_tag(x_156, 0); + x_159 = x_156; + lean_ctor_set_tag(x_159, 0); } -lean_ctor_set(x_156, 0, x_155); -lean_ctor_set(x_156, 1, x_152); -return x_156; +lean_ctor_set(x_159, 0, x_158); +lean_ctor_set(x_159, 1, x_155); +return x_159; } } } } else { -uint8_t x_157; +uint8_t x_160; lean_free_object(x_12); lean_dec(x_17); lean_dec(x_15); @@ -26155,60 +26167,60 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_157 = !lean_is_exclusive(x_18); -if (x_157 == 0) +x_160 = !lean_is_exclusive(x_19); +if (x_160 == 0) { -lean_object* x_158; uint8_t x_159; lean_object* x_160; -x_158 = lean_ctor_get(x_18, 0); -lean_dec(x_158); -x_159 = 0; -x_160 = lean_box(x_159); -lean_ctor_set_tag(x_18, 0); -lean_ctor_set(x_18, 0, x_160); -return x_18; -} -else -{ -lean_object* x_161; uint8_t x_162; lean_object* x_163; lean_object* x_164; -x_161 = lean_ctor_get(x_18, 1); -lean_inc(x_161); -lean_dec(x_18); +lean_object* x_161; uint8_t x_162; lean_object* x_163; +x_161 = lean_ctor_get(x_19, 0); +lean_dec(x_161); x_162 = 0; x_163 = lean_box(x_162); -x_164 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_164, 0, x_163); -lean_ctor_set(x_164, 1, x_161); -return x_164; +lean_ctor_set_tag(x_19, 0); +lean_ctor_set(x_19, 0, x_163); +return x_19; +} +else +{ +lean_object* x_164; uint8_t x_165; lean_object* x_166; lean_object* x_167; +x_164 = lean_ctor_get(x_19, 1); +lean_inc(x_164); +lean_dec(x_19); +x_165 = 0; +x_166 = lean_box(x_165); +x_167 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_167, 0, x_166); +lean_ctor_set(x_167, 1, x_164); +return x_167; } } } else { -lean_object* x_165; lean_object* x_166; lean_object* x_167; uint8_t x_168; lean_object* x_169; -x_165 = lean_ctor_get(x_12, 0); -x_166 = lean_ctor_get(x_12, 1); -x_167 = lean_ctor_get(x_12, 2); -x_168 = lean_ctor_get_uint8(x_12, sizeof(void*)*3); -lean_inc(x_167); -lean_inc(x_166); -lean_inc(x_165); +lean_object* x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; lean_object* x_172; +x_168 = lean_ctor_get(x_12, 0); +x_169 = lean_ctor_get(x_12, 1); +x_170 = lean_ctor_get(x_12, 2); +x_171 = lean_ctor_get_uint8(x_12, sizeof(void*)*4); +lean_inc(x_170); +lean_inc(x_169); +lean_inc(x_168); lean_dec(x_12); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); lean_inc(x_1); -x_169 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_mkInst_x3f(x_1, x_166, x_5, x_6, x_7, x_8, x_13); -if (lean_obj_tag(x_169) == 0) +x_172 = l___private_Lean_Elab_MutualDef_0__Lean_Elab_Term_mkInst_x3f(x_1, x_169, x_5, x_6, x_7, x_8, x_13); +if (lean_obj_tag(x_172) == 0) { -lean_object* x_170; -x_170 = lean_ctor_get(x_169, 0); -lean_inc(x_170); -if (lean_obj_tag(x_170) == 0) +lean_object* x_173; +x_173 = lean_ctor_get(x_172, 0); +lean_inc(x_173); +if (lean_obj_tag(x_173) == 0) { -lean_object* x_171; lean_object* x_172; uint8_t x_173; lean_object* x_174; lean_object* x_175; -lean_dec(x_167); -lean_dec(x_165); +lean_object* x_174; lean_object* x_175; uint8_t x_176; lean_object* x_177; lean_object* x_178; +lean_dec(x_170); +lean_dec(x_168); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); @@ -26217,259 +26229,264 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_171 = lean_ctor_get(x_169, 1); -lean_inc(x_171); -if (lean_is_exclusive(x_169)) { - lean_ctor_release(x_169, 0); - lean_ctor_release(x_169, 1); - x_172 = x_169; -} else { - lean_dec_ref(x_169); - x_172 = lean_box(0); -} -x_173 = 0; -x_174 = lean_box(x_173); -if (lean_is_scalar(x_172)) { - x_175 = lean_alloc_ctor(0, 2, 0); -} else { +x_174 = lean_ctor_get(x_172, 1); +lean_inc(x_174); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); x_175 = x_172; +} else { + lean_dec_ref(x_172); + x_175 = lean_box(0); } -lean_ctor_set(x_175, 0, x_174); -lean_ctor_set(x_175, 1, x_171); -return x_175; +x_176 = 0; +x_177 = lean_box(x_176); +if (lean_is_scalar(x_175)) { + x_178 = lean_alloc_ctor(0, 2, 0); +} else { + x_178 = x_175; +} +lean_ctor_set(x_178, 0, x_177); +lean_ctor_set(x_178, 1, x_174); +return x_178; } else { -lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; -x_176 = lean_ctor_get(x_169, 1); -lean_inc(x_176); -lean_dec(x_169); -x_177 = lean_ctor_get(x_170, 0); -lean_inc(x_177); -lean_dec(x_170); -x_178 = lean_ctor_get(x_177, 1); -lean_inc(x_178); -x_179 = l_Lean_Expr_appFn_x21(x_178); -lean_dec(x_178); -x_180 = lean_ctor_get(x_165, 1); +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; +x_179 = lean_ctor_get(x_172, 1); +lean_inc(x_179); +lean_dec(x_172); +x_180 = lean_ctor_get(x_173, 0); lean_inc(x_180); -if (lean_is_exclusive(x_165)) { - lean_ctor_release(x_165, 0); - lean_ctor_release(x_165, 1); - lean_ctor_release(x_165, 2); - x_181 = x_165; +lean_dec(x_173); +x_181 = lean_ctor_get(x_180, 1); +lean_inc(x_181); +x_182 = l_Lean_Expr_appFn_x21(x_181); +lean_dec(x_181); +x_183 = lean_ctor_get(x_168, 1); +lean_inc(x_183); +if (lean_is_exclusive(x_168)) { + lean_ctor_release(x_168, 0); + lean_ctor_release(x_168, 1); + lean_ctor_release(x_168, 2); + x_184 = x_168; } else { - lean_dec_ref(x_165); - x_181 = lean_box(0); + lean_dec_ref(x_168); + x_184 = lean_box(0); } -x_182 = lean_box(0); -lean_inc(x_180); -x_183 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_180, x_182); +x_185 = lean_box(0); +lean_inc(x_183); +x_186 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_183, x_185); lean_inc(x_2); -x_184 = l_Lean_mkConst(x_2, x_183); -x_185 = l_Lean_mkApp(x_179, x_184); +x_187 = l_Lean_mkConst(x_2, x_186); +x_188 = l_Lean_mkApp(x_182, x_187); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_185); -x_186 = l_Lean_Meta_check(x_185, x_5, x_6, x_7, x_8, x_176); -if (lean_obj_tag(x_186) == 0) +lean_inc(x_188); +x_189 = l_Lean_Meta_check(x_188, x_5, x_6, x_7, x_8, x_179); +if (lean_obj_tag(x_189) == 0) { -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; -x_187 = lean_ctor_get(x_186, 1); -lean_inc(x_187); -lean_dec(x_186); -x_188 = l_Lean_Elab_Term_processDefDeriving___closed__1; -x_189 = lean_name_append_before(x_2, x_188); -x_190 = l_Lean_Name_getString_x21(x_1); -x_191 = lean_name_append_after(x_189, x_190); -x_192 = lean_alloc_closure((void*)(l_Lean_Elab_mkUnusedBaseName), 3, 1); -lean_closure_set(x_192, 0, x_191); +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_190 = lean_ctor_get(x_189, 1); +lean_inc(x_190); +lean_dec(x_189); +x_191 = l_Lean_Elab_Term_processDefDeriving___closed__1; +x_192 = lean_name_append_before(x_2, x_191); +x_193 = l_Lean_Name_getString_x21(x_1); +x_194 = lean_name_append_after(x_192, x_193); +x_195 = lean_alloc_closure((void*)(l_Lean_Elab_mkUnusedBaseName), 3, 1); +lean_closure_set(x_195, 0, x_194); lean_inc(x_7); lean_inc(x_3); -x_193 = l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1(x_192, x_3, x_4, x_5, x_6, x_7, x_8, x_187); -if (lean_obj_tag(x_193) == 0) +x_196 = l_Lean_Elab_liftMacroM___at_Lean_Elab_Term_processDefDeriving___spec__1(x_195, x_3, x_4, x_5, x_6, x_7, x_8, x_190); +if (lean_obj_tag(x_196) == 0) { -lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; -x_194 = lean_ctor_get(x_193, 0); -lean_inc(x_194); -x_195 = lean_ctor_get(x_193, 1); -lean_inc(x_195); -lean_dec(x_193); -lean_inc(x_6); -x_196 = l_Lean_Meta_instantiateMVars(x_185, x_5, x_6, x_7, x_8, x_195); +lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; x_197 = lean_ctor_get(x_196, 0); lean_inc(x_197); x_198 = lean_ctor_get(x_196, 1); lean_inc(x_198); lean_dec(x_196); -x_199 = lean_ctor_get(x_177, 0); -lean_inc(x_199); -lean_dec(x_177); lean_inc(x_6); -x_200 = l_Lean_Meta_instantiateMVars(x_199, x_5, x_6, x_7, x_8, x_198); -x_201 = lean_ctor_get(x_200, 0); +x_199 = l_Lean_Meta_instantiateMVars(x_188, x_5, x_6, x_7, x_8, x_198); +x_200 = lean_ctor_get(x_199, 0); +lean_inc(x_200); +x_201 = lean_ctor_get(x_199, 1); lean_inc(x_201); -x_202 = lean_ctor_get(x_200, 1); +lean_dec(x_199); +x_202 = lean_ctor_get(x_180, 0); lean_inc(x_202); -lean_dec(x_200); -lean_inc(x_194); -if (lean_is_scalar(x_181)) { - x_203 = lean_alloc_ctor(0, 3, 0); +lean_dec(x_180); +lean_inc(x_6); +x_203 = l_Lean_Meta_instantiateMVars(x_202, x_5, x_6, x_7, x_8, x_201); +x_204 = lean_ctor_get(x_203, 0); +lean_inc(x_204); +x_205 = lean_ctor_get(x_203, 1); +lean_inc(x_205); +lean_dec(x_203); +lean_inc(x_197); +if (lean_is_scalar(x_184)) { + x_206 = lean_alloc_ctor(0, 3, 0); } else { - x_203 = x_181; + x_206 = x_184; } -lean_ctor_set(x_203, 0, x_194); -lean_ctor_set(x_203, 1, x_180); -lean_ctor_set(x_203, 2, x_197); -x_204 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_204, 0, x_203); -lean_ctor_set(x_204, 1, x_201); -lean_ctor_set(x_204, 2, x_167); -lean_ctor_set_uint8(x_204, sizeof(void*)*3, x_168); -x_205 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_205, 0, x_204); +lean_ctor_set(x_206, 0, x_197); +lean_ctor_set(x_206, 1, x_183); +lean_ctor_set(x_206, 2, x_200); +lean_inc(x_197); +x_207 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_207, 0, x_197); +lean_ctor_set(x_207, 1, x_185); +x_208 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_208, 0, x_206); +lean_ctor_set(x_208, 1, x_204); +lean_ctor_set(x_208, 2, x_170); +lean_ctor_set(x_208, 3, x_207); +lean_ctor_set_uint8(x_208, sizeof(void*)*4, x_171); +x_209 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_209, 0, x_208); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_206 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_205, x_3, x_4, x_5, x_6, x_7, x_8, x_202); -if (lean_obj_tag(x_206) == 0) -{ -lean_object* x_207; uint8_t x_208; lean_object* x_209; lean_object* x_210; -x_207 = lean_ctor_get(x_206, 1); -lean_inc(x_207); -lean_dec(x_206); -x_208 = 0; -x_209 = lean_unsigned_to_nat(1000u); -x_210 = l_Lean_Meta_addInstance(x_194, x_208, x_209, x_5, x_6, x_7, x_8, x_207); +x_210 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_209, x_3, x_4, x_5, x_6, x_7, x_8, x_205); if (lean_obj_tag(x_210) == 0) { -lean_object* x_211; lean_object* x_212; uint8_t x_213; lean_object* x_214; lean_object* x_215; +lean_object* x_211; uint8_t x_212; lean_object* x_213; lean_object* x_214; x_211 = lean_ctor_get(x_210, 1); lean_inc(x_211); -if (lean_is_exclusive(x_210)) { - lean_ctor_release(x_210, 0); - lean_ctor_release(x_210, 1); - x_212 = x_210; +lean_dec(x_210); +x_212 = 0; +x_213 = lean_unsigned_to_nat(1000u); +x_214 = l_Lean_Meta_addInstance(x_197, x_212, x_213, x_5, x_6, x_7, x_8, x_211); +if (lean_obj_tag(x_214) == 0) +{ +lean_object* x_215; lean_object* x_216; uint8_t x_217; lean_object* x_218; lean_object* x_219; +x_215 = lean_ctor_get(x_214, 1); +lean_inc(x_215); +if (lean_is_exclusive(x_214)) { + lean_ctor_release(x_214, 0); + lean_ctor_release(x_214, 1); + x_216 = x_214; } else { - lean_dec_ref(x_210); - x_212 = lean_box(0); + lean_dec_ref(x_214); + x_216 = lean_box(0); } -x_213 = 1; -x_214 = lean_box(x_213); -if (lean_is_scalar(x_212)) { - x_215 = lean_alloc_ctor(0, 2, 0); +x_217 = 1; +x_218 = lean_box(x_217); +if (lean_is_scalar(x_216)) { + x_219 = lean_alloc_ctor(0, 2, 0); } else { - x_215 = x_212; + x_219 = x_216; } -lean_ctor_set(x_215, 0, x_214); -lean_ctor_set(x_215, 1, x_211); -return x_215; +lean_ctor_set(x_219, 0, x_218); +lean_ctor_set(x_219, 1, x_215); +return x_219; } else { -lean_object* x_216; lean_object* x_217; uint8_t x_218; lean_object* x_219; lean_object* x_220; -x_216 = lean_ctor_get(x_210, 1); -lean_inc(x_216); -if (lean_is_exclusive(x_210)) { - lean_ctor_release(x_210, 0); - lean_ctor_release(x_210, 1); - x_217 = x_210; +lean_object* x_220; lean_object* x_221; uint8_t x_222; lean_object* x_223; lean_object* x_224; +x_220 = lean_ctor_get(x_214, 1); +lean_inc(x_220); +if (lean_is_exclusive(x_214)) { + lean_ctor_release(x_214, 0); + lean_ctor_release(x_214, 1); + x_221 = x_214; } else { - lean_dec_ref(x_210); - x_217 = lean_box(0); + lean_dec_ref(x_214); + x_221 = lean_box(0); } -x_218 = 0; -x_219 = lean_box(x_218); -if (lean_is_scalar(x_217)) { - x_220 = lean_alloc_ctor(0, 2, 0); +x_222 = 0; +x_223 = lean_box(x_222); +if (lean_is_scalar(x_221)) { + x_224 = lean_alloc_ctor(0, 2, 0); } else { - x_220 = x_217; - lean_ctor_set_tag(x_220, 0); + x_224 = x_221; + lean_ctor_set_tag(x_224, 0); } -lean_ctor_set(x_220, 0, x_219); -lean_ctor_set(x_220, 1, x_216); -return x_220; +lean_ctor_set(x_224, 0, x_223); +lean_ctor_set(x_224, 1, x_220); +return x_224; } } else { -lean_object* x_221; lean_object* x_222; uint8_t x_223; lean_object* x_224; lean_object* x_225; -lean_dec(x_194); +lean_object* x_225; lean_object* x_226; uint8_t x_227; lean_object* x_228; lean_object* x_229; +lean_dec(x_197); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_221 = lean_ctor_get(x_206, 1); -lean_inc(x_221); -if (lean_is_exclusive(x_206)) { - lean_ctor_release(x_206, 0); - lean_ctor_release(x_206, 1); - x_222 = x_206; +x_225 = lean_ctor_get(x_210, 1); +lean_inc(x_225); +if (lean_is_exclusive(x_210)) { + lean_ctor_release(x_210, 0); + lean_ctor_release(x_210, 1); + x_226 = x_210; } else { - lean_dec_ref(x_206); - x_222 = lean_box(0); + lean_dec_ref(x_210); + x_226 = lean_box(0); } -x_223 = 0; -x_224 = lean_box(x_223); -if (lean_is_scalar(x_222)) { - x_225 = lean_alloc_ctor(0, 2, 0); +x_227 = 0; +x_228 = lean_box(x_227); +if (lean_is_scalar(x_226)) { + x_229 = lean_alloc_ctor(0, 2, 0); } else { - x_225 = x_222; - lean_ctor_set_tag(x_225, 0); + x_229 = x_226; + lean_ctor_set_tag(x_229, 0); } -lean_ctor_set(x_225, 0, x_224); -lean_ctor_set(x_225, 1, x_221); -return x_225; +lean_ctor_set(x_229, 0, x_228); +lean_ctor_set(x_229, 1, x_225); +return x_229; } } else { -lean_object* x_226; lean_object* x_227; uint8_t x_228; lean_object* x_229; lean_object* x_230; -lean_dec(x_185); -lean_dec(x_181); +lean_object* x_230; lean_object* x_231; uint8_t x_232; lean_object* x_233; lean_object* x_234; +lean_dec(x_188); +lean_dec(x_184); +lean_dec(x_183); lean_dec(x_180); -lean_dec(x_177); -lean_dec(x_167); +lean_dec(x_170); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_226 = lean_ctor_get(x_193, 1); -lean_inc(x_226); -if (lean_is_exclusive(x_193)) { - lean_ctor_release(x_193, 0); - lean_ctor_release(x_193, 1); - x_227 = x_193; +x_230 = lean_ctor_get(x_196, 1); +lean_inc(x_230); +if (lean_is_exclusive(x_196)) { + lean_ctor_release(x_196, 0); + lean_ctor_release(x_196, 1); + x_231 = x_196; } else { - lean_dec_ref(x_193); - x_227 = lean_box(0); + lean_dec_ref(x_196); + x_231 = lean_box(0); } -x_228 = 0; -x_229 = lean_box(x_228); -if (lean_is_scalar(x_227)) { - x_230 = lean_alloc_ctor(0, 2, 0); +x_232 = 0; +x_233 = lean_box(x_232); +if (lean_is_scalar(x_231)) { + x_234 = lean_alloc_ctor(0, 2, 0); } else { - x_230 = x_227; - lean_ctor_set_tag(x_230, 0); + x_234 = x_231; + lean_ctor_set_tag(x_234, 0); } -lean_ctor_set(x_230, 0, x_229); -lean_ctor_set(x_230, 1, x_226); -return x_230; +lean_ctor_set(x_234, 0, x_233); +lean_ctor_set(x_234, 1, x_230); +return x_234; } } else { -lean_object* x_231; lean_object* x_232; uint8_t x_233; lean_object* x_234; lean_object* x_235; -lean_dec(x_185); -lean_dec(x_181); +lean_object* x_235; lean_object* x_236; uint8_t x_237; lean_object* x_238; lean_object* x_239; +lean_dec(x_188); +lean_dec(x_184); +lean_dec(x_183); lean_dec(x_180); -lean_dec(x_177); -lean_dec(x_167); +lean_dec(x_170); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); @@ -26478,35 +26495,35 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_231 = lean_ctor_get(x_186, 1); -lean_inc(x_231); -if (lean_is_exclusive(x_186)) { - lean_ctor_release(x_186, 0); - lean_ctor_release(x_186, 1); - x_232 = x_186; +x_235 = lean_ctor_get(x_189, 1); +lean_inc(x_235); +if (lean_is_exclusive(x_189)) { + lean_ctor_release(x_189, 0); + lean_ctor_release(x_189, 1); + x_236 = x_189; } else { - lean_dec_ref(x_186); - x_232 = lean_box(0); + lean_dec_ref(x_189); + x_236 = lean_box(0); } -x_233 = 0; -x_234 = lean_box(x_233); -if (lean_is_scalar(x_232)) { - x_235 = lean_alloc_ctor(0, 2, 0); +x_237 = 0; +x_238 = lean_box(x_237); +if (lean_is_scalar(x_236)) { + x_239 = lean_alloc_ctor(0, 2, 0); } else { - x_235 = x_232; - lean_ctor_set_tag(x_235, 0); + x_239 = x_236; + lean_ctor_set_tag(x_239, 0); } -lean_ctor_set(x_235, 0, x_234); -lean_ctor_set(x_235, 1, x_231); -return x_235; +lean_ctor_set(x_239, 0, x_238); +lean_ctor_set(x_239, 1, x_235); +return x_239; } } } else { -lean_object* x_236; lean_object* x_237; uint8_t x_238; lean_object* x_239; lean_object* x_240; -lean_dec(x_167); -lean_dec(x_165); +lean_object* x_240; lean_object* x_241; uint8_t x_242; lean_object* x_243; lean_object* x_244; +lean_dec(x_170); +lean_dec(x_168); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); @@ -26515,33 +26532,33 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_236 = lean_ctor_get(x_169, 1); -lean_inc(x_236); -if (lean_is_exclusive(x_169)) { - lean_ctor_release(x_169, 0); - lean_ctor_release(x_169, 1); - x_237 = x_169; +x_240 = lean_ctor_get(x_172, 1); +lean_inc(x_240); +if (lean_is_exclusive(x_172)) { + lean_ctor_release(x_172, 0); + lean_ctor_release(x_172, 1); + x_241 = x_172; } else { - lean_dec_ref(x_169); - x_237 = lean_box(0); + lean_dec_ref(x_172); + x_241 = lean_box(0); } -x_238 = 0; -x_239 = lean_box(x_238); -if (lean_is_scalar(x_237)) { - x_240 = lean_alloc_ctor(0, 2, 0); +x_242 = 0; +x_243 = lean_box(x_242); +if (lean_is_scalar(x_241)) { + x_244 = lean_alloc_ctor(0, 2, 0); } else { - x_240 = x_237; - lean_ctor_set_tag(x_240, 0); + x_244 = x_241; + lean_ctor_set_tag(x_244, 0); } -lean_ctor_set(x_240, 0, x_239); -lean_ctor_set(x_240, 1, x_236); -return x_240; +lean_ctor_set(x_244, 0, x_243); +lean_ctor_set(x_244, 1, x_240); +return x_244; } } } else { -uint8_t x_241; +uint8_t x_245; lean_dec(x_11); lean_dec(x_8); lean_dec(x_7); @@ -26551,35 +26568,35 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_241 = !lean_is_exclusive(x_10); -if (x_241 == 0) +x_245 = !lean_is_exclusive(x_10); +if (x_245 == 0) { -lean_object* x_242; uint8_t x_243; lean_object* x_244; -x_242 = lean_ctor_get(x_10, 0); -lean_dec(x_242); -x_243 = 0; -x_244 = lean_box(x_243); -lean_ctor_set(x_10, 0, x_244); +lean_object* x_246; uint8_t x_247; lean_object* x_248; +x_246 = lean_ctor_get(x_10, 0); +lean_dec(x_246); +x_247 = 0; +x_248 = lean_box(x_247); +lean_ctor_set(x_10, 0, x_248); return x_10; } else { -lean_object* x_245; uint8_t x_246; lean_object* x_247; lean_object* x_248; -x_245 = lean_ctor_get(x_10, 1); -lean_inc(x_245); +lean_object* x_249; uint8_t x_250; lean_object* x_251; lean_object* x_252; +x_249 = lean_ctor_get(x_10, 1); +lean_inc(x_249); lean_dec(x_10); -x_246 = 0; -x_247 = lean_box(x_246); -x_248 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_248, 0, x_247); -lean_ctor_set(x_248, 1, x_245); -return x_248; +x_250 = 0; +x_251 = lean_box(x_250); +x_252 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_252, 0, x_251); +lean_ctor_set(x_252, 1, x_249); +return x_252; } } } else { -uint8_t x_249; +uint8_t x_253; lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); @@ -26588,30 +26605,30 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_249 = !lean_is_exclusive(x_10); -if (x_249 == 0) +x_253 = !lean_is_exclusive(x_10); +if (x_253 == 0) { -lean_object* x_250; uint8_t x_251; lean_object* x_252; -x_250 = lean_ctor_get(x_10, 0); -lean_dec(x_250); -x_251 = 0; -x_252 = lean_box(x_251); +lean_object* x_254; uint8_t x_255; lean_object* x_256; +x_254 = lean_ctor_get(x_10, 0); +lean_dec(x_254); +x_255 = 0; +x_256 = lean_box(x_255); lean_ctor_set_tag(x_10, 0); -lean_ctor_set(x_10, 0, x_252); +lean_ctor_set(x_10, 0, x_256); return x_10; } else { -lean_object* x_253; uint8_t x_254; lean_object* x_255; lean_object* x_256; -x_253 = lean_ctor_get(x_10, 1); -lean_inc(x_253); +lean_object* x_257; uint8_t x_258; lean_object* x_259; lean_object* x_260; +x_257 = lean_ctor_get(x_10, 1); +lean_inc(x_257); lean_dec(x_10); -x_254 = 0; -x_255 = lean_box(x_254); -x_256 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_256, 0, x_255); -lean_ctor_set(x_256, 1, x_253); -return x_256; +x_258 = 0; +x_259 = lean_box(x_258); +x_260 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_260, 0, x_259); +lean_ctor_set(x_260, 1, x_257); +return x_260; } } } diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c b/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c index 36536e21c0..b235d6f36f 100644 --- a/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c +++ b/stage0/stdlib/Lean/Elab/PreDefinition/Basic.c @@ -3673,7 +3673,7 @@ x_18 = lean_box(x_17); switch (lean_obj_tag(x_18)) { case 1: { -lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; x_19 = lean_ctor_get(x_15, 1); lean_inc(x_19); lean_dec(x_15); @@ -3683,472 +3683,520 @@ x_21 = lean_ctor_get(x_16, 1); lean_inc(x_21); x_22 = lean_ctor_get(x_16, 4); lean_inc(x_22); +lean_inc(x_20); x_23 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_23, 0, x_20); lean_ctor_set(x_23, 1, x_21); lean_ctor_set(x_23, 2, x_22); x_24 = lean_ctor_get(x_16, 5); lean_inc(x_24); -x_25 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_25, 0, x_23); -lean_ctor_set(x_25, 1, x_24); -x_26 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_26, 0, x_25); -x_27 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_26, x_4, x_5, x_6, x_7, x_8, x_9, x_19); -return x_27; +x_25 = lean_box(0); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_20); +lean_ctor_set(x_26, 1, x_25); +x_27 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_27, 0, x_23); +lean_ctor_set(x_27, 1, x_24); +lean_ctor_set(x_27, 2, x_26); +x_28 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_28, 0, x_27); +x_29 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_28, x_4, x_5, x_6, x_7, x_8, x_9, x_19); +return x_29; } case 3: { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; -x_28 = lean_ctor_get(x_15, 1); -lean_inc(x_28); -lean_dec(x_15); -x_29 = lean_ctor_get(x_16, 3); -lean_inc(x_29); -x_30 = lean_ctor_get(x_16, 1); +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; uint8_t x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_30 = lean_ctor_get(x_15, 1); lean_inc(x_30); -x_31 = lean_ctor_get(x_16, 4); +lean_dec(x_15); +x_31 = lean_ctor_get(x_16, 3); lean_inc(x_31); -x_32 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_32, 0, x_29); -lean_ctor_set(x_32, 1, x_30); -lean_ctor_set(x_32, 2, x_31); -x_33 = lean_ctor_get(x_16, 5); +x_32 = lean_ctor_get(x_16, 1); +lean_inc(x_32); +x_33 = lean_ctor_get(x_16, 4); lean_inc(x_33); -x_34 = lean_ctor_get(x_16, 2); -lean_inc(x_34); -x_35 = lean_ctor_get_uint8(x_34, sizeof(void*)*2 + 3); -lean_dec(x_34); -x_36 = lean_alloc_ctor(0, 2, 1); -lean_ctor_set(x_36, 0, x_32); -lean_ctor_set(x_36, 1, x_33); -lean_ctor_set_uint8(x_36, sizeof(void*)*2, x_35); -x_37 = lean_alloc_ctor(3, 1, 0); -lean_ctor_set(x_37, 0, x_36); -x_38 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_37, x_4, x_5, x_6, x_7, x_8, x_9, x_28); -return x_38; +lean_inc(x_31); +x_34 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_34, 0, x_31); +lean_ctor_set(x_34, 1, x_32); +lean_ctor_set(x_34, 2, x_33); +x_35 = lean_ctor_get(x_16, 5); +lean_inc(x_35); +x_36 = lean_ctor_get(x_16, 2); +lean_inc(x_36); +x_37 = lean_ctor_get_uint8(x_36, sizeof(void*)*2 + 3); +lean_dec(x_36); +x_38 = lean_box(0); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_31); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_alloc_ctor(0, 3, 1); +lean_ctor_set(x_40, 0, x_34); +lean_ctor_set(x_40, 1, x_35); +lean_ctor_set(x_40, 2, x_39); +lean_ctor_set_uint8(x_40, sizeof(void*)*3, x_37); +x_41 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_41, 0, x_40); +x_42 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_41, x_4, x_5, x_6, x_7, x_8, x_9, x_30); +return x_42; } case 4: { -lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; -x_39 = lean_ctor_get(x_15, 1); -lean_inc(x_39); +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; +x_43 = lean_ctor_get(x_15, 1); +lean_inc(x_43); lean_dec(x_15); -x_40 = lean_ctor_get(x_16, 3); -lean_inc(x_40); -x_41 = lean_ctor_get(x_16, 1); -lean_inc(x_41); -x_42 = lean_ctor_get(x_16, 4); -lean_inc(x_42); -x_43 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_43, 0, x_40); -lean_ctor_set(x_43, 1, x_41); -lean_ctor_set(x_43, 2, x_42); -x_44 = lean_ctor_get(x_16, 2); +x_44 = lean_ctor_get(x_16, 3); lean_inc(x_44); -x_45 = lean_ctor_get_uint8(x_44, sizeof(void*)*2 + 3); -lean_dec(x_44); -if (x_45 == 0) -{ -lean_object* x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; -x_46 = lean_ctor_get(x_16, 5); +x_45 = lean_ctor_get(x_16, 1); +lean_inc(x_45); +x_46 = lean_ctor_get(x_16, 4); lean_inc(x_46); -x_47 = lean_box(1); -x_48 = 1; -x_49 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_49, 0, x_43); -lean_ctor_set(x_49, 1, x_46); -lean_ctor_set(x_49, 2, x_47); -lean_ctor_set_uint8(x_49, sizeof(void*)*3, x_48); -x_50 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_50, 0, x_49); -x_51 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_50, x_4, x_5, x_6, x_7, x_8, x_9, x_39); -return x_51; +lean_inc(x_44); +x_47 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_47, 0, x_44); +lean_ctor_set(x_47, 1, x_45); +lean_ctor_set(x_47, 2, x_46); +x_48 = lean_ctor_get(x_16, 5); +lean_inc(x_48); +x_49 = lean_ctor_get(x_16, 2); +lean_inc(x_49); +x_50 = lean_ctor_get_uint8(x_49, sizeof(void*)*2 + 3); +lean_dec(x_49); +x_51 = lean_box(0); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_44); +lean_ctor_set(x_52, 1, x_51); +if (x_50 == 0) +{ +lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_53 = lean_box(1); +x_54 = 1; +x_55 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_55, 0, x_47); +lean_ctor_set(x_55, 1, x_48); +lean_ctor_set(x_55, 2, x_53); +lean_ctor_set(x_55, 3, x_52); +lean_ctor_set_uint8(x_55, sizeof(void*)*4, x_54); +x_56 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_56, 0, x_55); +x_57 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_56, x_4, x_5, x_6, x_7, x_8, x_9, x_43); +return x_57; } else { -lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_52 = lean_ctor_get(x_16, 5); -lean_inc(x_52); -x_53 = lean_box(1); -x_54 = 0; -x_55 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_55, 0, x_43); -lean_ctor_set(x_55, 1, x_52); -lean_ctor_set(x_55, 2, x_53); -lean_ctor_set_uint8(x_55, sizeof(void*)*3, x_54); -x_56 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_56, x_4, x_5, x_6, x_7, x_8, x_9, x_39); -return x_57; +lean_object* x_58; uint8_t x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_58 = lean_box(1); +x_59 = 0; +x_60 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_60, 0, x_47); +lean_ctor_set(x_60, 1, x_48); +lean_ctor_set(x_60, 2, x_58); +lean_ctor_set(x_60, 3, x_52); +lean_ctor_set_uint8(x_60, sizeof(void*)*4, x_59); +x_61 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_61, 0, x_60); +x_62 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_61, x_4, x_5, x_6, x_7, x_8, x_9, x_43); +return x_62; } } default: { -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint32_t x_69; uint32_t x_70; uint32_t x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint32_t x_74; uint32_t x_75; uint32_t x_76; lean_object* x_77; lean_object* x_78; uint8_t x_79; lean_object* x_80; lean_object* x_81; lean_dec(x_18); -x_58 = lean_ctor_get(x_15, 1); -lean_inc(x_58); -lean_dec(x_15); -x_59 = lean_st_ref_get(x_9, x_58); -x_60 = lean_ctor_get(x_59, 0); -lean_inc(x_60); -x_61 = lean_ctor_get(x_59, 1); -lean_inc(x_61); -lean_dec(x_59); -x_62 = lean_ctor_get(x_60, 0); -lean_inc(x_62); -lean_dec(x_60); -x_63 = lean_ctor_get(x_16, 3); +x_63 = lean_ctor_get(x_15, 1); lean_inc(x_63); -x_64 = lean_ctor_get(x_16, 1); -lean_inc(x_64); -x_65 = lean_ctor_get(x_16, 4); +lean_dec(x_15); +x_64 = lean_st_ref_get(x_9, x_63); +x_65 = lean_ctor_get(x_64, 0); lean_inc(x_65); -x_66 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_66, 0, x_63); -lean_ctor_set(x_66, 1, x_64); -lean_ctor_set(x_66, 2, x_65); -x_67 = lean_ctor_get(x_16, 5); +x_66 = lean_ctor_get(x_64, 1); +lean_inc(x_66); +lean_dec(x_64); +x_67 = lean_ctor_get(x_65, 0); lean_inc(x_67); -lean_inc(x_67); -x_68 = l_Lean_getMaxHeight(x_62, x_67); -x_69 = lean_unbox_uint32(x_68); -lean_dec(x_68); -x_70 = 1; -x_71 = lean_uint32_add(x_69, x_70); -x_72 = lean_alloc_ctor(2, 0, 4); -lean_ctor_set_uint32(x_72, 0, x_71); -x_73 = lean_ctor_get(x_16, 2); -lean_inc(x_73); -x_74 = lean_ctor_get_uint8(x_73, sizeof(void*)*2 + 3); +lean_dec(x_65); +x_68 = lean_ctor_get(x_16, 3); +lean_inc(x_68); +x_69 = lean_ctor_get(x_16, 1); +lean_inc(x_69); +x_70 = lean_ctor_get(x_16, 4); +lean_inc(x_70); +lean_inc(x_68); +x_71 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_71, 0, x_68); +lean_ctor_set(x_71, 1, x_69); +lean_ctor_set(x_71, 2, x_70); +x_72 = lean_ctor_get(x_16, 5); +lean_inc(x_72); +lean_inc(x_72); +x_73 = l_Lean_getMaxHeight(x_67, x_72); +x_74 = lean_unbox_uint32(x_73); lean_dec(x_73); -if (x_74 == 0) -{ -uint8_t x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; x_75 = 1; -x_76 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_76, 0, x_66); -lean_ctor_set(x_76, 1, x_67); -lean_ctor_set(x_76, 2, x_72); -lean_ctor_set_uint8(x_76, sizeof(void*)*3, x_75); -x_77 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_77, 0, x_76); -x_78 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_77, x_4, x_5, x_6, x_7, x_8, x_9, x_61); -return x_78; +x_76 = lean_uint32_add(x_74, x_75); +x_77 = lean_alloc_ctor(2, 0, 4); +lean_ctor_set_uint32(x_77, 0, x_76); +x_78 = lean_ctor_get(x_16, 2); +lean_inc(x_78); +x_79 = lean_ctor_get_uint8(x_78, sizeof(void*)*2 + 3); +lean_dec(x_78); +x_80 = lean_box(0); +x_81 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_81, 0, x_68); +lean_ctor_set(x_81, 1, x_80); +if (x_79 == 0) +{ +uint8_t x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_82 = 1; +x_83 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_83, 0, x_71); +lean_ctor_set(x_83, 1, x_72); +lean_ctor_set(x_83, 2, x_77); +lean_ctor_set(x_83, 3, x_81); +lean_ctor_set_uint8(x_83, sizeof(void*)*4, x_82); +x_84 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_84, 0, x_83); +x_85 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_84, x_4, x_5, x_6, x_7, x_8, x_9, x_66); +return x_85; } else { -uint8_t x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_79 = 0; -x_80 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_80, 0, x_66); -lean_ctor_set(x_80, 1, x_67); -lean_ctor_set(x_80, 2, x_72); -lean_ctor_set_uint8(x_80, sizeof(void*)*3, x_79); -x_81 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_81, 0, x_80); -x_82 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_81, x_4, x_5, x_6, x_7, x_8, x_9, x_61); -return x_82; +uint8_t x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_86 = 0; +x_87 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_87, 0, x_71); +lean_ctor_set(x_87, 1, x_72); +lean_ctor_set(x_87, 2, x_77); +lean_ctor_set(x_87, 3, x_81); +lean_ctor_set_uint8(x_87, sizeof(void*)*4, x_86); +x_88 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_88, 0, x_87); +x_89 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_16, x_3, x_2, x_88, x_4, x_5, x_6, x_7, x_8, x_9, x_66); +return x_89; } } } } else { -uint8_t x_83; +uint8_t x_90; lean_dec(x_8); lean_dec(x_9); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -x_83 = !lean_is_exclusive(x_15); -if (x_83 == 0) +x_90 = !lean_is_exclusive(x_15); +if (x_90 == 0) { return x_15; } else { -lean_object* x_84; lean_object* x_85; lean_object* x_86; -x_84 = lean_ctor_get(x_15, 0); -x_85 = lean_ctor_get(x_15, 1); -lean_inc(x_85); -lean_inc(x_84); +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_15, 0); +x_92 = lean_ctor_get(x_15, 1); +lean_inc(x_92); +lean_inc(x_91); lean_dec(x_15); -x_86 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_86, 0, x_84); -lean_ctor_set(x_86, 1, x_85); -return x_86; +x_93 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set(x_93, 1, x_92); +return x_93; } } } else { -lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; -x_87 = lean_ctor_get(x_8, 0); -x_88 = lean_ctor_get(x_8, 1); -x_89 = lean_ctor_get(x_8, 2); -x_90 = lean_ctor_get(x_8, 3); -x_91 = lean_ctor_get(x_8, 4); -x_92 = lean_ctor_get(x_8, 5); -x_93 = lean_ctor_get(x_8, 6); -x_94 = lean_ctor_get(x_8, 7); -x_95 = lean_ctor_get(x_8, 8); -x_96 = lean_ctor_get(x_8, 9); -x_97 = lean_ctor_get(x_8, 10); +lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_94 = lean_ctor_get(x_8, 0); +x_95 = lean_ctor_get(x_8, 1); +x_96 = lean_ctor_get(x_8, 2); +x_97 = lean_ctor_get(x_8, 3); +x_98 = lean_ctor_get(x_8, 4); +x_99 = lean_ctor_get(x_8, 5); +x_100 = lean_ctor_get(x_8, 6); +x_101 = lean_ctor_get(x_8, 7); +x_102 = lean_ctor_get(x_8, 8); +x_103 = lean_ctor_get(x_8, 9); +x_104 = lean_ctor_get(x_8, 10); +lean_inc(x_104); +lean_inc(x_103); +lean_inc(x_102); +lean_inc(x_101); +lean_inc(x_100); +lean_inc(x_99); +lean_inc(x_98); lean_inc(x_97); lean_inc(x_96); lean_inc(x_95); lean_inc(x_94); -lean_inc(x_93); -lean_inc(x_92); -lean_inc(x_91); -lean_inc(x_90); -lean_inc(x_89); -lean_inc(x_88); -lean_inc(x_87); lean_dec(x_8); -x_98 = l_Lean_replaceRef(x_11, x_92); -lean_dec(x_92); +x_105 = l_Lean_replaceRef(x_11, x_99); +lean_dec(x_99); lean_dec(x_11); -x_99 = lean_alloc_ctor(0, 11, 0); -lean_ctor_set(x_99, 0, x_87); -lean_ctor_set(x_99, 1, x_88); -lean_ctor_set(x_99, 2, x_89); -lean_ctor_set(x_99, 3, x_90); -lean_ctor_set(x_99, 4, x_91); -lean_ctor_set(x_99, 5, x_98); -lean_ctor_set(x_99, 6, x_93); -lean_ctor_set(x_99, 7, x_94); -lean_ctor_set(x_99, 8, x_95); -lean_ctor_set(x_99, 9, x_96); -lean_ctor_set(x_99, 10, x_97); +x_106 = lean_alloc_ctor(0, 11, 0); +lean_ctor_set(x_106, 0, x_94); +lean_ctor_set(x_106, 1, x_95); +lean_ctor_set(x_106, 2, x_96); +lean_ctor_set(x_106, 3, x_97); +lean_ctor_set(x_106, 4, x_98); +lean_ctor_set(x_106, 5, x_105); +lean_ctor_set(x_106, 6, x_100); +lean_ctor_set(x_106, 7, x_101); +lean_ctor_set(x_106, 8, x_102); +lean_ctor_set(x_106, 9, x_103); +lean_ctor_set(x_106, 10, x_104); lean_inc(x_9); -lean_inc(x_99); +lean_inc(x_106); lean_inc(x_7); lean_inc(x_6); -x_100 = l_Lean_Elab_abstractNestedProofs(x_1, x_6, x_7, x_99, x_9, x_10); -if (lean_obj_tag(x_100) == 0) +x_107 = l_Lean_Elab_abstractNestedProofs(x_1, x_6, x_7, x_106, x_9, x_10); +if (lean_obj_tag(x_107) == 0) { -lean_object* x_101; uint8_t x_102; lean_object* x_103; -x_101 = lean_ctor_get(x_100, 0); -lean_inc(x_101); -x_102 = lean_ctor_get_uint8(x_101, sizeof(void*)*6); -x_103 = lean_box(x_102); -switch (lean_obj_tag(x_103)) { +lean_object* x_108; uint8_t x_109; lean_object* x_110; +x_108 = lean_ctor_get(x_107, 0); +lean_inc(x_108); +x_109 = lean_ctor_get_uint8(x_108, sizeof(void*)*6); +x_110 = lean_box(x_109); +switch (lean_obj_tag(x_110)) { case 1: { -lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; -x_104 = lean_ctor_get(x_100, 1); -lean_inc(x_104); -lean_dec(x_100); -x_105 = lean_ctor_get(x_101, 3); -lean_inc(x_105); -x_106 = lean_ctor_get(x_101, 1); -lean_inc(x_106); -x_107 = lean_ctor_get(x_101, 4); -lean_inc(x_107); -x_108 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_108, 0, x_105); -lean_ctor_set(x_108, 1, x_106); -lean_ctor_set(x_108, 2, x_107); -x_109 = lean_ctor_get(x_101, 5); -lean_inc(x_109); -x_110 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_110, 0, x_108); -lean_ctor_set(x_110, 1, x_109); -x_111 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_111, 0, x_110); -x_112 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_101, x_3, x_2, x_111, x_4, x_5, x_6, x_7, x_99, x_9, x_104); -return x_112; +lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +x_111 = lean_ctor_get(x_107, 1); +lean_inc(x_111); +lean_dec(x_107); +x_112 = lean_ctor_get(x_108, 3); +lean_inc(x_112); +x_113 = lean_ctor_get(x_108, 1); +lean_inc(x_113); +x_114 = lean_ctor_get(x_108, 4); +lean_inc(x_114); +lean_inc(x_112); +x_115 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_115, 0, x_112); +lean_ctor_set(x_115, 1, x_113); +lean_ctor_set(x_115, 2, x_114); +x_116 = lean_ctor_get(x_108, 5); +lean_inc(x_116); +x_117 = lean_box(0); +x_118 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_118, 0, x_112); +lean_ctor_set(x_118, 1, x_117); +x_119 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_119, 0, x_115); +lean_ctor_set(x_119, 1, x_116); +lean_ctor_set(x_119, 2, x_118); +x_120 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_120, 0, x_119); +x_121 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_108, x_3, x_2, x_120, x_4, x_5, x_6, x_7, x_106, x_9, x_111); +return x_121; } case 3: { -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; -x_113 = lean_ctor_get(x_100, 1); -lean_inc(x_113); -lean_dec(x_100); -x_114 = lean_ctor_get(x_101, 3); -lean_inc(x_114); -x_115 = lean_ctor_get(x_101, 1); -lean_inc(x_115); -x_116 = lean_ctor_get(x_101, 4); -lean_inc(x_116); -x_117 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_117, 0, x_114); -lean_ctor_set(x_117, 1, x_115); -lean_ctor_set(x_117, 2, x_116); -x_118 = lean_ctor_get(x_101, 5); -lean_inc(x_118); -x_119 = lean_ctor_get(x_101, 2); -lean_inc(x_119); -x_120 = lean_ctor_get_uint8(x_119, sizeof(void*)*2 + 3); -lean_dec(x_119); -x_121 = lean_alloc_ctor(0, 2, 1); -lean_ctor_set(x_121, 0, x_117); -lean_ctor_set(x_121, 1, x_118); -lean_ctor_set_uint8(x_121, sizeof(void*)*2, x_120); -x_122 = lean_alloc_ctor(3, 1, 0); -lean_ctor_set(x_122, 0, x_121); -x_123 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_101, x_3, x_2, x_122, x_4, x_5, x_6, x_7, x_99, x_9, x_113); -return x_123; +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; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_122 = lean_ctor_get(x_107, 1); +lean_inc(x_122); +lean_dec(x_107); +x_123 = lean_ctor_get(x_108, 3); +lean_inc(x_123); +x_124 = lean_ctor_get(x_108, 1); +lean_inc(x_124); +x_125 = lean_ctor_get(x_108, 4); +lean_inc(x_125); +lean_inc(x_123); +x_126 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_126, 0, x_123); +lean_ctor_set(x_126, 1, x_124); +lean_ctor_set(x_126, 2, x_125); +x_127 = lean_ctor_get(x_108, 5); +lean_inc(x_127); +x_128 = lean_ctor_get(x_108, 2); +lean_inc(x_128); +x_129 = lean_ctor_get_uint8(x_128, sizeof(void*)*2 + 3); +lean_dec(x_128); +x_130 = lean_box(0); +x_131 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_131, 0, x_123); +lean_ctor_set(x_131, 1, x_130); +x_132 = lean_alloc_ctor(0, 3, 1); +lean_ctor_set(x_132, 0, x_126); +lean_ctor_set(x_132, 1, x_127); +lean_ctor_set(x_132, 2, x_131); +lean_ctor_set_uint8(x_132, sizeof(void*)*3, x_129); +x_133 = lean_alloc_ctor(3, 1, 0); +lean_ctor_set(x_133, 0, x_132); +x_134 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_108, x_3, x_2, x_133, x_4, x_5, x_6, x_7, x_106, x_9, x_122); +return x_134; } case 4: { -lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; -x_124 = lean_ctor_get(x_100, 1); -lean_inc(x_124); -lean_dec(x_100); -x_125 = lean_ctor_get(x_101, 3); -lean_inc(x_125); -x_126 = lean_ctor_get(x_101, 1); -lean_inc(x_126); -x_127 = lean_ctor_get(x_101, 4); -lean_inc(x_127); -x_128 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_128, 0, x_125); -lean_ctor_set(x_128, 1, x_126); -lean_ctor_set(x_128, 2, x_127); -x_129 = lean_ctor_get(x_101, 2); -lean_inc(x_129); -x_130 = lean_ctor_get_uint8(x_129, sizeof(void*)*2 + 3); -lean_dec(x_129); -if (x_130 == 0) +lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; uint8_t x_142; lean_object* x_143; lean_object* x_144; +x_135 = lean_ctor_get(x_107, 1); +lean_inc(x_135); +lean_dec(x_107); +x_136 = lean_ctor_get(x_108, 3); +lean_inc(x_136); +x_137 = lean_ctor_get(x_108, 1); +lean_inc(x_137); +x_138 = lean_ctor_get(x_108, 4); +lean_inc(x_138); +lean_inc(x_136); +x_139 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_139, 0, x_136); +lean_ctor_set(x_139, 1, x_137); +lean_ctor_set(x_139, 2, x_138); +x_140 = lean_ctor_get(x_108, 5); +lean_inc(x_140); +x_141 = lean_ctor_get(x_108, 2); +lean_inc(x_141); +x_142 = lean_ctor_get_uint8(x_141, sizeof(void*)*2 + 3); +lean_dec(x_141); +x_143 = lean_box(0); +x_144 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_144, 0, x_136); +lean_ctor_set(x_144, 1, x_143); +if (x_142 == 0) { -lean_object* x_131; lean_object* x_132; uint8_t x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; -x_131 = lean_ctor_get(x_101, 5); -lean_inc(x_131); -x_132 = lean_box(1); -x_133 = 1; -x_134 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_134, 0, x_128); -lean_ctor_set(x_134, 1, x_131); -lean_ctor_set(x_134, 2, x_132); -lean_ctor_set_uint8(x_134, sizeof(void*)*3, x_133); -x_135 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_135, 0, x_134); -x_136 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_101, x_3, x_2, x_135, x_4, x_5, x_6, x_7, x_99, x_9, x_124); -return x_136; +lean_object* x_145; uint8_t x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; +x_145 = lean_box(1); +x_146 = 1; +x_147 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_147, 0, x_139); +lean_ctor_set(x_147, 1, x_140); +lean_ctor_set(x_147, 2, x_145); +lean_ctor_set(x_147, 3, x_144); +lean_ctor_set_uint8(x_147, sizeof(void*)*4, x_146); +x_148 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_148, 0, x_147); +x_149 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_108, x_3, x_2, x_148, x_4, x_5, x_6, x_7, x_106, x_9, x_135); +return x_149; } else { -lean_object* x_137; lean_object* x_138; uint8_t x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; -x_137 = lean_ctor_get(x_101, 5); -lean_inc(x_137); -x_138 = lean_box(1); -x_139 = 0; -x_140 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_140, 0, x_128); -lean_ctor_set(x_140, 1, x_137); -lean_ctor_set(x_140, 2, x_138); -lean_ctor_set_uint8(x_140, sizeof(void*)*3, x_139); -x_141 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_141, 0, x_140); -x_142 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_101, x_3, x_2, x_141, x_4, x_5, x_6, x_7, x_99, x_9, x_124); -return x_142; +lean_object* x_150; uint8_t x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_150 = lean_box(1); +x_151 = 0; +x_152 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_152, 0, x_139); +lean_ctor_set(x_152, 1, x_140); +lean_ctor_set(x_152, 2, x_150); +lean_ctor_set(x_152, 3, x_144); +lean_ctor_set_uint8(x_152, sizeof(void*)*4, x_151); +x_153 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_153, 0, x_152); +x_154 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_108, x_3, x_2, x_153, x_4, x_5, x_6, x_7, x_106, x_9, x_135); +return x_154; } } default: { -lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; uint32_t x_154; uint32_t x_155; uint32_t x_156; lean_object* x_157; lean_object* x_158; uint8_t x_159; -lean_dec(x_103); -x_143 = lean_ctor_get(x_100, 1); -lean_inc(x_143); -lean_dec(x_100); -x_144 = lean_st_ref_get(x_9, x_143); -x_145 = lean_ctor_get(x_144, 0); -lean_inc(x_145); -x_146 = lean_ctor_get(x_144, 1); -lean_inc(x_146); -lean_dec(x_144); -x_147 = lean_ctor_get(x_145, 0); -lean_inc(x_147); -lean_dec(x_145); -x_148 = lean_ctor_get(x_101, 3); -lean_inc(x_148); -x_149 = lean_ctor_get(x_101, 1); -lean_inc(x_149); -x_150 = lean_ctor_get(x_101, 4); -lean_inc(x_150); -x_151 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_151, 0, x_148); -lean_ctor_set(x_151, 1, x_149); -lean_ctor_set(x_151, 2, x_150); -x_152 = lean_ctor_get(x_101, 5); -lean_inc(x_152); -lean_inc(x_152); -x_153 = l_Lean_getMaxHeight(x_147, x_152); -x_154 = lean_unbox_uint32(x_153); -lean_dec(x_153); -x_155 = 1; -x_156 = lean_uint32_add(x_154, x_155); -x_157 = lean_alloc_ctor(2, 0, 4); -lean_ctor_set_uint32(x_157, 0, x_156); -x_158 = lean_ctor_get(x_101, 2); +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; uint32_t x_166; uint32_t x_167; uint32_t x_168; lean_object* x_169; lean_object* x_170; uint8_t x_171; lean_object* x_172; lean_object* x_173; +lean_dec(x_110); +x_155 = lean_ctor_get(x_107, 1); +lean_inc(x_155); +lean_dec(x_107); +x_156 = lean_st_ref_get(x_9, x_155); +x_157 = lean_ctor_get(x_156, 0); +lean_inc(x_157); +x_158 = lean_ctor_get(x_156, 1); lean_inc(x_158); -x_159 = lean_ctor_get_uint8(x_158, sizeof(void*)*2 + 3); -lean_dec(x_158); -if (x_159 == 0) +lean_dec(x_156); +x_159 = lean_ctor_get(x_157, 0); +lean_inc(x_159); +lean_dec(x_157); +x_160 = lean_ctor_get(x_108, 3); +lean_inc(x_160); +x_161 = lean_ctor_get(x_108, 1); +lean_inc(x_161); +x_162 = lean_ctor_get(x_108, 4); +lean_inc(x_162); +lean_inc(x_160); +x_163 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_163, 0, x_160); +lean_ctor_set(x_163, 1, x_161); +lean_ctor_set(x_163, 2, x_162); +x_164 = lean_ctor_get(x_108, 5); +lean_inc(x_164); +lean_inc(x_164); +x_165 = l_Lean_getMaxHeight(x_159, x_164); +x_166 = lean_unbox_uint32(x_165); +lean_dec(x_165); +x_167 = 1; +x_168 = lean_uint32_add(x_166, x_167); +x_169 = lean_alloc_ctor(2, 0, 4); +lean_ctor_set_uint32(x_169, 0, x_168); +x_170 = lean_ctor_get(x_108, 2); +lean_inc(x_170); +x_171 = lean_ctor_get_uint8(x_170, sizeof(void*)*2 + 3); +lean_dec(x_170); +x_172 = lean_box(0); +x_173 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_173, 0, x_160); +lean_ctor_set(x_173, 1, x_172); +if (x_171 == 0) { -uint8_t x_160; lean_object* x_161; lean_object* x_162; lean_object* x_163; -x_160 = 1; -x_161 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_161, 0, x_151); -lean_ctor_set(x_161, 1, x_152); -lean_ctor_set(x_161, 2, x_157); -lean_ctor_set_uint8(x_161, sizeof(void*)*3, x_160); -x_162 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_162, 0, x_161); -x_163 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_101, x_3, x_2, x_162, x_4, x_5, x_6, x_7, x_99, x_9, x_146); -return x_163; +uint8_t x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; +x_174 = 1; +x_175 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_175, 0, x_163); +lean_ctor_set(x_175, 1, x_164); +lean_ctor_set(x_175, 2, x_169); +lean_ctor_set(x_175, 3, x_173); +lean_ctor_set_uint8(x_175, sizeof(void*)*4, x_174); +x_176 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_176, 0, x_175); +x_177 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_108, x_3, x_2, x_176, x_4, x_5, x_6, x_7, x_106, x_9, x_158); +return x_177; } else { -uint8_t x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; -x_164 = 0; -x_165 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_165, 0, x_151); -lean_ctor_set(x_165, 1, x_152); -lean_ctor_set(x_165, 2, x_157); -lean_ctor_set_uint8(x_165, sizeof(void*)*3, x_164); -x_166 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_166, 0, x_165); -x_167 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_101, x_3, x_2, x_166, x_4, x_5, x_6, x_7, x_99, x_9, x_146); -return x_167; +uint8_t x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; +x_178 = 0; +x_179 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_179, 0, x_163); +lean_ctor_set(x_179, 1, x_164); +lean_ctor_set(x_179, 2, x_169); +lean_ctor_set(x_179, 3, x_173); +lean_ctor_set_uint8(x_179, sizeof(void*)*4, x_178); +x_180 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_180, 0, x_179); +x_181 = l___private_Lean_Elab_PreDefinition_Basic_0__Lean_Elab_addNonRecAux___lambda__4(x_108, x_3, x_2, x_180, x_4, x_5, x_6, x_7, x_106, x_9, x_158); +return x_181; } } } } else { -lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; -lean_dec(x_99); +lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; +lean_dec(x_106); lean_dec(x_9); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -x_168 = lean_ctor_get(x_100, 0); -lean_inc(x_168); -x_169 = lean_ctor_get(x_100, 1); -lean_inc(x_169); -if (lean_is_exclusive(x_100)) { - lean_ctor_release(x_100, 0); - lean_ctor_release(x_100, 1); - x_170 = x_100; +x_182 = lean_ctor_get(x_107, 0); +lean_inc(x_182); +x_183 = lean_ctor_get(x_107, 1); +lean_inc(x_183); +if (lean_is_exclusive(x_107)) { + lean_ctor_release(x_107, 0); + lean_ctor_release(x_107, 1); + x_184 = x_107; } else { - lean_dec_ref(x_100); - x_170 = lean_box(0); + lean_dec_ref(x_107); + x_184 = lean_box(0); } -if (lean_is_scalar(x_170)) { - x_171 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_184)) { + x_185 = lean_alloc_ctor(1, 2, 0); } else { - x_171 = x_170; + x_185 = x_184; } -lean_ctor_set(x_171, 0, x_168); -lean_ctor_set(x_171, 1, x_169); -return x_171; +lean_ctor_set(x_185, 0, x_182); +lean_ctor_set(x_185, 1, x_183); +return x_185; } } } @@ -4741,7 +4789,7 @@ uint8_t x_12; x_12 = !lean_is_exclusive(x_2); if (x_12 == 0) { -lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; x_13 = lean_ctor_get(x_2, 0); x_14 = lean_ctor_get(x_2, 1); x_15 = lean_ctor_get(x_13, 3); @@ -4750,6 +4798,7 @@ x_16 = lean_ctor_get(x_13, 1); lean_inc(x_16); x_17 = lean_ctor_get(x_13, 4); lean_inc(x_17); +lean_inc(x_15); x_18 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_18, 0, x_15); lean_ctor_set(x_18, 1, x_16); @@ -4758,89 +4807,101 @@ x_19 = lean_ctor_get(x_13, 5); lean_inc(x_19); lean_dec(x_13); x_20 = lean_box(0); -x_21 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_21, 0, x_18); -lean_ctor_set(x_21, 1, x_19); -lean_ctor_set(x_21, 2, x_20); -lean_ctor_set_uint8(x_21, sizeof(void*)*3, x_1); -x_22 = l_List_mapM___at_Lean_Elab_addAndCompileUnsafe___spec__2(x_1, x_14, x_3, x_4, x_5, x_6, x_7, x_8, x_9); -x_23 = !lean_is_exclusive(x_22); -if (x_23 == 0) +lean_ctor_set(x_2, 1, x_20); +lean_ctor_set(x_2, 0, x_15); +x_21 = lean_box(0); +x_22 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_22, 0, x_18); +lean_ctor_set(x_22, 1, x_19); +lean_ctor_set(x_22, 2, x_21); +lean_ctor_set(x_22, 3, x_2); +lean_ctor_set_uint8(x_22, sizeof(void*)*4, x_1); +x_23 = l_List_mapM___at_Lean_Elab_addAndCompileUnsafe___spec__2(x_1, x_14, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +x_24 = !lean_is_exclusive(x_23); +if (x_24 == 0) { -lean_object* x_24; -x_24 = lean_ctor_get(x_22, 0); -lean_ctor_set(x_2, 1, x_24); -lean_ctor_set(x_2, 0, x_21); -lean_ctor_set(x_22, 0, x_2); -return x_22; +lean_object* x_25; lean_object* x_26; +x_25 = lean_ctor_get(x_23, 0); +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_22); +lean_ctor_set(x_26, 1, x_25); +lean_ctor_set(x_23, 0, x_26); +return x_23; } else { -lean_object* x_25; lean_object* x_26; lean_object* x_27; -x_25 = lean_ctor_get(x_22, 0); -x_26 = lean_ctor_get(x_22, 1); -lean_inc(x_26); -lean_inc(x_25); -lean_dec(x_22); -lean_ctor_set(x_2, 1, x_25); -lean_ctor_set(x_2, 0, x_21); -x_27 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_27, 0, x_2); -lean_ctor_set(x_27, 1, x_26); -return x_27; -} -} -else -{ -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_28 = lean_ctor_get(x_2, 0); -x_29 = lean_ctor_get(x_2, 1); -lean_inc(x_29); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_27 = lean_ctor_get(x_23, 0); +x_28 = lean_ctor_get(x_23, 1); lean_inc(x_28); -lean_dec(x_2); -x_30 = lean_ctor_get(x_28, 3); -lean_inc(x_30); -x_31 = lean_ctor_get(x_28, 1); -lean_inc(x_31); -x_32 = lean_ctor_get(x_28, 4); +lean_inc(x_27); +lean_dec(x_23); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_22); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_30, 0, x_29); +lean_ctor_set(x_30, 1, x_28); +return x_30; +} +} +else +{ +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_31 = lean_ctor_get(x_2, 0); +x_32 = lean_ctor_get(x_2, 1); lean_inc(x_32); -x_33 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_33, 0, x_30); -lean_ctor_set(x_33, 1, x_31); -lean_ctor_set(x_33, 2, x_32); -x_34 = lean_ctor_get(x_28, 5); +lean_inc(x_31); +lean_dec(x_2); +x_33 = lean_ctor_get(x_31, 3); +lean_inc(x_33); +x_34 = lean_ctor_get(x_31, 1); lean_inc(x_34); -lean_dec(x_28); -x_35 = lean_box(0); -x_36 = lean_alloc_ctor(0, 3, 1); +x_35 = lean_ctor_get(x_31, 4); +lean_inc(x_35); +lean_inc(x_33); +x_36 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_36, 0, x_33); lean_ctor_set(x_36, 1, x_34); lean_ctor_set(x_36, 2, x_35); -lean_ctor_set_uint8(x_36, sizeof(void*)*3, x_1); -x_37 = l_List_mapM___at_Lean_Elab_addAndCompileUnsafe___spec__2(x_1, x_29, x_3, x_4, x_5, x_6, x_7, x_8, x_9); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -x_39 = lean_ctor_get(x_37, 1); -lean_inc(x_39); -if (lean_is_exclusive(x_37)) { - lean_ctor_release(x_37, 0); - lean_ctor_release(x_37, 1); - x_40 = x_37; -} else { - lean_dec_ref(x_37); - x_40 = lean_box(0); -} -x_41 = lean_alloc_ctor(1, 2, 0); +x_37 = lean_ctor_get(x_31, 5); +lean_inc(x_37); +lean_dec(x_31); +x_38 = lean_box(0); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_33); +lean_ctor_set(x_39, 1, x_38); +x_40 = lean_box(0); +x_41 = lean_alloc_ctor(0, 4, 1); lean_ctor_set(x_41, 0, x_36); -lean_ctor_set(x_41, 1, x_38); -if (lean_is_scalar(x_40)) { - x_42 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_41, 1, x_37); +lean_ctor_set(x_41, 2, x_40); +lean_ctor_set(x_41, 3, x_39); +lean_ctor_set_uint8(x_41, sizeof(void*)*4, x_1); +x_42 = l_List_mapM___at_Lean_Elab_addAndCompileUnsafe___spec__2(x_1, x_32, x_3, x_4, x_5, x_6, x_7, x_8, x_9); +x_43 = lean_ctor_get(x_42, 0); +lean_inc(x_43); +x_44 = lean_ctor_get(x_42, 1); +lean_inc(x_44); +if (lean_is_exclusive(x_42)) { + lean_ctor_release(x_42, 0); + lean_ctor_release(x_42, 1); + x_45 = x_42; } else { - x_42 = x_40; + lean_dec_ref(x_42); + x_45 = lean_box(0); } -lean_ctor_set(x_42, 0, x_41); -lean_ctor_set(x_42, 1, x_39); -return x_42; +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_41); +lean_ctor_set(x_46, 1, x_43); +if (lean_is_scalar(x_45)) { + x_47 = lean_alloc_ctor(0, 2, 0); +} else { + x_47 = x_45; +} +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_44); +return x_47; } } } diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Eqns.c b/stage0/stdlib/Lean/Elab/PreDefinition/Eqns.c index 4ff145a03e..9ac7dfae9c 100644 --- a/stage0/stdlib/Lean/Elab/PreDefinition/Eqns.c +++ b/stage0/stdlib/Lean/Elab/PreDefinition/Eqns.c @@ -22279,7 +22279,7 @@ lean_dec(x_32); x_35 = l_Lean_Meta_mkLambdaFVars(x_4, x_33, x_26, x_27, x_28, x_6, x_7, x_8, x_9, x_34); if (lean_obj_tag(x_35) == 0) { -lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +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_36 = lean_ctor_get(x_35, 0); lean_inc(x_36); x_37 = lean_ctor_get(x_35, 1); @@ -22292,92 +22292,97 @@ x_40 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_40, 0, x_39); lean_ctor_set(x_40, 1, x_11); lean_ctor_set(x_40, 2, x_30); -x_41 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_41, 0, x_40); -lean_ctor_set(x_41, 1, x_36); -x_42 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_42, 0, x_41); -x_43 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_42, x_6, x_7, x_8, x_9, x_37); -if (lean_obj_tag(x_43) == 0) +lean_inc(x_39); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_12); +x_42 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_36); +lean_ctor_set(x_42, 2, x_41); +x_43 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_43, 0, x_42); +x_44 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_43, x_6, x_7, x_8, x_9, x_37); +if (lean_obj_tag(x_44) == 0) { -uint8_t x_44; -x_44 = !lean_is_exclusive(x_43); -if (x_44 == 0) +uint8_t x_45; +x_45 = !lean_is_exclusive(x_44); +if (x_45 == 0) { -lean_object* x_45; -x_45 = lean_ctor_get(x_43, 0); -lean_dec(x_45); -lean_ctor_set(x_43, 0, x_39); -return x_43; +lean_object* x_46; +x_46 = lean_ctor_get(x_44, 0); +lean_dec(x_46); +lean_ctor_set(x_44, 0, x_39); +return x_44; } else { -lean_object* x_46; lean_object* x_47; -x_46 = lean_ctor_get(x_43, 1); -lean_inc(x_46); -lean_dec(x_43); -x_47 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_47, 0, x_39); -lean_ctor_set(x_47, 1, x_46); -return x_47; +lean_object* x_47; lean_object* x_48; +x_47 = lean_ctor_get(x_44, 1); +lean_inc(x_47); +lean_dec(x_44); +x_48 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_48, 0, x_39); +lean_ctor_set(x_48, 1, x_47); +return x_48; } } else { -uint8_t x_48; +uint8_t x_49; lean_dec(x_39); -x_48 = !lean_is_exclusive(x_43); -if (x_48 == 0) +x_49 = !lean_is_exclusive(x_44); +if (x_49 == 0) { -return x_43; +return x_44; } else { -lean_object* x_49; lean_object* x_50; lean_object* x_51; -x_49 = lean_ctor_get(x_43, 0); -x_50 = lean_ctor_get(x_43, 1); +lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_50 = lean_ctor_get(x_44, 0); +x_51 = lean_ctor_get(x_44, 1); +lean_inc(x_51); lean_inc(x_50); -lean_inc(x_49); -lean_dec(x_43); -x_51 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_51, 0, x_49); -lean_ctor_set(x_51, 1, x_50); -return x_51; +lean_dec(x_44); +x_52 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_52, 0, x_50); +lean_ctor_set(x_52, 1, x_51); +return x_52; } } } else { -uint8_t x_52; +uint8_t x_53; lean_dec(x_30); lean_dec(x_11); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -x_52 = !lean_is_exclusive(x_35); -if (x_52 == 0) +x_53 = !lean_is_exclusive(x_35); +if (x_53 == 0) { return x_35; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = lean_ctor_get(x_35, 0); -x_54 = lean_ctor_get(x_35, 1); +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_35, 0); +x_55 = lean_ctor_get(x_35, 1); +lean_inc(x_55); lean_inc(x_54); -lean_inc(x_53); lean_dec(x_35); -x_55 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_55, 0, x_53); -lean_ctor_set(x_55, 1, x_54); -return x_55; +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_54); +lean_ctor_set(x_56, 1, x_55); +return x_56; } } } else { -uint8_t x_56; +uint8_t x_57; lean_dec(x_21); lean_dec(x_11); lean_dec(x_9); @@ -22385,29 +22390,29 @@ lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_4); -x_56 = !lean_is_exclusive(x_29); -if (x_56 == 0) +x_57 = !lean_is_exclusive(x_29); +if (x_57 == 0) { return x_29; } else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; -x_57 = lean_ctor_get(x_29, 0); -x_58 = lean_ctor_get(x_29, 1); +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_29, 0); +x_59 = lean_ctor_get(x_29, 1); +lean_inc(x_59); lean_inc(x_58); -lean_inc(x_57); lean_dec(x_29); -x_59 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_59, 0, x_57); -lean_ctor_set(x_59, 1, x_58); -return x_59; +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +return x_60; } } } else { -uint8_t x_60; +uint8_t x_61; lean_dec(x_21); lean_dec(x_17); lean_dec(x_11); @@ -22416,29 +22421,29 @@ lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_4); -x_60 = !lean_is_exclusive(x_24); -if (x_60 == 0) +x_61 = !lean_is_exclusive(x_24); +if (x_61 == 0) { return x_24; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; -x_61 = lean_ctor_get(x_24, 0); -x_62 = lean_ctor_get(x_24, 1); +lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_62 = lean_ctor_get(x_24, 0); +x_63 = lean_ctor_get(x_24, 1); +lean_inc(x_63); lean_inc(x_62); -lean_inc(x_61); lean_dec(x_24); -x_63 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_63, 0, x_61); -lean_ctor_set(x_63, 1, x_62); -return x_63; +x_64 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_64, 0, x_62); +lean_ctor_set(x_64, 1, x_63); +return x_64; } } } else { -uint8_t x_64; +uint8_t x_65; lean_dec(x_11); lean_dec(x_9); lean_dec(x_8); @@ -22446,23 +22451,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_4); lean_dec(x_2); -x_64 = !lean_is_exclusive(x_16); -if (x_64 == 0) +x_65 = !lean_is_exclusive(x_16); +if (x_65 == 0) { return x_16; } else { -lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_65 = lean_ctor_get(x_16, 0); -x_66 = lean_ctor_get(x_16, 1); +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_16, 0); +x_67 = lean_ctor_get(x_16, 1); +lean_inc(x_67); lean_inc(x_66); -lean_inc(x_65); lean_dec(x_16); -x_67 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_67, 0, x_65); -lean_ctor_set(x_67, 1, x_66); -return x_67; +x_68 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +return x_68; } } } diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/Structural/Eqns.c b/stage0/stdlib/Lean/Elab/PreDefinition/Structural/Eqns.c index d4ccd46856..c3d1805a40 100644 --- a/stage0/stdlib/Lean/Elab/PreDefinition/Structural/Eqns.c +++ b/stage0/stdlib/Lean/Elab/PreDefinition/Structural/Eqns.c @@ -16,7 +16,7 @@ extern "C" { size_t lean_usize_add(size_t, size_t); static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___closed__8; lean_object* l_Lean_Expr_mvarId_x21(lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__6; LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Structural_eqnInfoExt; @@ -54,7 +54,7 @@ lean_object* lean_nat_add(lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___closed__2; static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__7; lean_object* l_Lean_mkAppN(lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural_Eqns___hyg_1258____closed__1; lean_object* l_Lean_commitWhenSome_x3f___at_Lean_Meta_splitTarget_x3f___spec__1___at_Lean_Meta_splitTarget_x3f___spec__2(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Structural_getUnfoldFor_x3f___lambda__1___boxed(lean_object*, lean_object*, lean_object*); @@ -67,7 +67,7 @@ lean_object* l_Lean_MapDeclarationExtension_insert___rarg(lean_object*, lean_obj uint8_t lean_nat_dec_eq(lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___closed__6; lean_object* l_Lean_Elab_Eqns_simpIf_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_st_ref_take(lean_object*, lean_object*); static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___closed__1; lean_object* lean_nat_sub(lean_object*, lean_object*); @@ -110,7 +110,7 @@ lean_object* l_Lean_Name_append(lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___closed__3; LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___spec__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Eqns_whnfReducibleLHS_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(lean_object*, lean_object*); lean_object* lean_st_ref_set(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -1679,445 +1679,459 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { _start: { -lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; -x_13 = lean_unsigned_to_nat(1u); -x_14 = lean_nat_add(x_1, x_13); -x_15 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___closed__2; -x_16 = lean_name_append_index_after(x_15, x_14); -x_17 = l_Lean_Name_append(x_2, x_16); -lean_inc(x_17); -x_18 = lean_array_push(x_6, x_17); +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +x_14 = lean_unsigned_to_nat(1u); +x_15 = lean_nat_add(x_1, x_14); +x_16 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___closed__2; +x_17 = lean_name_append_index_after(x_16, x_15); +x_18 = l_Lean_Name_append(x_2, x_17); +lean_inc(x_18); +x_19 = lean_array_push(x_7, x_18); +lean_inc(x_12); lean_inc(x_11); lean_inc(x_10); lean_inc(x_9); -lean_inc(x_8); lean_inc(x_4); -x_19 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof(x_3, x_4, x_8, x_9, x_10, x_11, x_12); -if (lean_obj_tag(x_19) == 0) +x_20 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof(x_3, x_4, x_9, x_10, x_11, x_12, x_13); +if (lean_obj_tag(x_20) == 0) { -lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -x_20 = lean_ctor_get(x_19, 0); -lean_inc(x_20); -x_21 = lean_ctor_get(x_19, 1); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; +x_21 = lean_ctor_get(x_20, 0); lean_inc(x_21); -lean_dec(x_19); -x_22 = l_Lean_Elab_Eqns_removeUnusedEqnHypotheses(x_4, x_20, x_10, x_11, x_21); -x_23 = lean_ctor_get(x_22, 0); -lean_inc(x_23); -x_24 = lean_ctor_get(x_22, 1); +x_22 = lean_ctor_get(x_20, 1); +lean_inc(x_22); +lean_dec(x_20); +x_23 = l_Lean_Elab_Eqns_removeUnusedEqnHypotheses(x_4, x_21, x_11, x_12, x_22); +x_24 = lean_ctor_get(x_23, 0); lean_inc(x_24); -lean_dec(x_22); -x_25 = lean_ctor_get(x_23, 0); +x_25 = lean_ctor_get(x_23, 1); lean_inc(x_25); -x_26 = lean_ctor_get(x_23, 1); -lean_inc(x_26); lean_dec(x_23); -x_27 = lean_ctor_get(x_5, 1); +x_26 = lean_ctor_get(x_24, 0); +lean_inc(x_26); +x_27 = lean_ctor_get(x_24, 1); lean_inc(x_27); -x_28 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_28, 0, x_17); -lean_ctor_set(x_28, 1, x_27); -lean_ctor_set(x_28, 2, x_25); -x_29 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_29, 0, x_28); -lean_ctor_set(x_29, 1, x_26); -x_30 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_30, 0, x_29); -x_31 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_30, x_8, x_9, x_10, x_11, x_24); -if (lean_obj_tag(x_31) == 0) +lean_dec(x_24); +x_28 = lean_ctor_get(x_5, 1); +lean_inc(x_28); +lean_inc(x_18); +x_29 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_29, 0, x_18); +lean_ctor_set(x_29, 1, x_28); +lean_ctor_set(x_29, 2, x_26); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_18); +lean_ctor_set(x_30, 1, x_6); +x_31 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_27); +lean_ctor_set(x_31, 2, x_30); +x_32 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_32, 0, x_31); +x_33 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_32, x_9, x_10, x_11, x_12, x_25); +if (lean_obj_tag(x_33) == 0) { -uint8_t x_32; -x_32 = !lean_is_exclusive(x_31); -if (x_32 == 0) +uint8_t x_34; +x_34 = !lean_is_exclusive(x_33); +if (x_34 == 0) { -lean_object* x_33; lean_object* x_34; -x_33 = lean_ctor_get(x_31, 0); +lean_object* x_35; lean_object* x_36; +x_35 = lean_ctor_get(x_33, 0); +lean_dec(x_35); +x_36 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_36, 0, x_19); +lean_ctor_set(x_33, 0, x_36); +return x_33; +} +else +{ +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_33, 1); +lean_inc(x_37); lean_dec(x_33); -x_34 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_34, 0, x_18); -lean_ctor_set(x_31, 0, x_34); -return x_31; +x_38 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_38, 0, x_19); +x_39 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_39, 0, x_38); +lean_ctor_set(x_39, 1, x_37); +return x_39; +} +} +else +{ +uint8_t x_40; +lean_dec(x_19); +x_40 = !lean_is_exclusive(x_33); +if (x_40 == 0) +{ +return x_33; +} +else +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_33, 0); +x_42 = lean_ctor_get(x_33, 1); +lean_inc(x_42); +lean_inc(x_41); +lean_dec(x_33); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; +} +} +} +else +{ +uint8_t x_44; +lean_dec(x_19); +lean_dec(x_18); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_4); +x_44 = !lean_is_exclusive(x_20); +if (x_44 == 0) +{ +return x_20; +} +else +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_20, 0); +x_46 = lean_ctor_get(x_20, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_20); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} +} +} +} +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { +_start: +{ +uint8_t x_16; +x_16 = lean_nat_dec_le(x_8, x_7); +if (x_16 == 0) +{ +lean_object* x_17; uint8_t x_18; +x_17 = lean_unsigned_to_nat(0u); +x_18 = lean_nat_dec_eq(x_6, x_17); +if (x_18 == 0) +{ +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; +x_19 = lean_unsigned_to_nat(1u); +x_20 = lean_nat_sub(x_6, x_19); +lean_dec(x_6); +x_21 = l_Lean_instInhabitedExpr; +x_22 = lean_array_get(x_21, x_2, x_7); +x_23 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___closed__8; +x_67 = lean_st_ref_get(x_14, x_15); +x_68 = lean_ctor_get(x_67, 0); +lean_inc(x_68); +x_69 = lean_ctor_get(x_68, 3); +lean_inc(x_69); +lean_dec(x_68); +x_70 = lean_ctor_get_uint8(x_69, sizeof(void*)*1); +lean_dec(x_69); +if (x_70 == 0) +{ +lean_object* x_71; uint8_t x_72; +x_71 = lean_ctor_get(x_67, 1); +lean_inc(x_71); +lean_dec(x_67); +x_72 = 0; +x_24 = x_72; +x_25 = x_71; +goto block_66; +} +else +{ +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; +x_73 = lean_ctor_get(x_67, 1); +lean_inc(x_73); +lean_dec(x_67); +x_74 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_23, x_11, x_12, x_13, x_14, x_73); +x_75 = lean_ctor_get(x_74, 0); +lean_inc(x_75); +x_76 = lean_ctor_get(x_74, 1); +lean_inc(x_76); +lean_dec(x_74); +x_77 = lean_unbox(x_75); +lean_dec(x_75); +x_24 = x_77; +x_25 = x_76; +goto block_66; +} +block_66: +{ +if (x_24 == 0) +{ +lean_object* x_26; lean_object* x_27; +x_26 = lean_box(0); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_inc(x_11); +lean_inc(x_5); +lean_inc(x_3); +x_27 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(x_7, x_4, x_3, x_22, x_1, x_5, x_10, x_26, x_11, x_12, x_13, x_14, x_25); +if (lean_obj_tag(x_27) == 0) +{ +lean_object* x_28; +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +if (lean_obj_tag(x_28) == 0) +{ +uint8_t x_29; +lean_dec(x_20); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_3); +x_29 = !lean_is_exclusive(x_27); +if (x_29 == 0) +{ +lean_object* x_30; lean_object* x_31; +x_30 = lean_ctor_get(x_27, 0); +lean_dec(x_30); +x_31 = lean_ctor_get(x_28, 0); +lean_inc(x_31); +lean_dec(x_28); +lean_ctor_set(x_27, 0, x_31); +return x_27; +} +else +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_27, 1); +lean_inc(x_32); +lean_dec(x_27); +x_33 = lean_ctor_get(x_28, 0); +lean_inc(x_33); +lean_dec(x_28); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_32); +return x_34; +} } else { lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_35 = lean_ctor_get(x_31, 1); -lean_inc(x_35); -lean_dec(x_31); -x_36 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_36, 0, x_18); -x_37 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_37, 0, x_36); -lean_ctor_set(x_37, 1, x_35); -return x_37; -} -} -else -{ -uint8_t x_38; -lean_dec(x_18); -x_38 = !lean_is_exclusive(x_31); -if (x_38 == 0) -{ -return x_31; -} -else -{ -lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_39 = lean_ctor_get(x_31, 0); -x_40 = lean_ctor_get(x_31, 1); -lean_inc(x_40); -lean_inc(x_39); -lean_dec(x_31); -x_41 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_41, 0, x_39); -lean_ctor_set(x_41, 1, x_40); -return x_41; -} -} -} -else -{ -uint8_t x_42; -lean_dec(x_18); -lean_dec(x_17); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_4); -x_42 = !lean_is_exclusive(x_19); -if (x_42 == 0) -{ -return x_19; -} -else -{ -lean_object* x_43; lean_object* x_44; lean_object* x_45; -x_43 = lean_ctor_get(x_19, 0); -x_44 = lean_ctor_get(x_19, 1); -lean_inc(x_44); -lean_inc(x_43); -lean_dec(x_19); -x_45 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_45, 0, x_43); -lean_ctor_set(x_45, 1, x_44); -return x_45; -} -} -} -} -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { -_start: -{ -uint8_t x_15; -x_15 = lean_nat_dec_le(x_7, x_6); -if (x_15 == 0) -{ -lean_object* x_16; uint8_t x_17; -x_16 = lean_unsigned_to_nat(0u); -x_17 = lean_nat_dec_eq(x_5, x_16); -if (x_17 == 0) -{ -lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; lean_object* x_24; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; -x_18 = lean_unsigned_to_nat(1u); -x_19 = lean_nat_sub(x_5, x_18); -lean_dec(x_5); -x_20 = l_Lean_instInhabitedExpr; -x_21 = lean_array_get(x_20, x_2, x_6); -x_22 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___closed__8; -x_66 = lean_st_ref_get(x_13, x_14); -x_67 = lean_ctor_get(x_66, 0); -lean_inc(x_67); -x_68 = lean_ctor_get(x_67, 3); -lean_inc(x_68); -lean_dec(x_67); -x_69 = lean_ctor_get_uint8(x_68, sizeof(void*)*1); -lean_dec(x_68); -if (x_69 == 0) -{ -lean_object* x_70; uint8_t x_71; -x_70 = lean_ctor_get(x_66, 1); -lean_inc(x_70); -lean_dec(x_66); -x_71 = 0; -x_23 = x_71; -x_24 = x_70; -goto block_65; -} -else -{ -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; -x_72 = lean_ctor_get(x_66, 1); -lean_inc(x_72); -lean_dec(x_66); -x_73 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_22, x_10, x_11, x_12, x_13, x_72); -x_74 = lean_ctor_get(x_73, 0); -lean_inc(x_74); -x_75 = lean_ctor_get(x_73, 1); -lean_inc(x_75); -lean_dec(x_73); -x_76 = lean_unbox(x_74); -lean_dec(x_74); -x_23 = x_76; -x_24 = x_75; -goto block_65; -} -block_65: -{ -if (x_23 == 0) -{ -lean_object* x_25; lean_object* x_26; -x_25 = lean_box(0); -lean_inc(x_13); -lean_inc(x_12); -lean_inc(x_11); -lean_inc(x_10); -lean_inc(x_3); -x_26 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(x_6, x_4, x_3, x_21, x_1, x_9, x_25, x_10, x_11, x_12, x_13, x_24); -if (lean_obj_tag(x_26) == 0) -{ -lean_object* x_27; -x_27 = lean_ctor_get(x_26, 0); -lean_inc(x_27); -if (lean_obj_tag(x_27) == 0) -{ -uint8_t x_28; -lean_dec(x_19); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_3); -x_28 = !lean_is_exclusive(x_26); -if (x_28 == 0) -{ -lean_object* x_29; lean_object* x_30; -x_29 = lean_ctor_get(x_26, 0); -lean_dec(x_29); -x_30 = lean_ctor_get(x_27, 0); -lean_inc(x_30); -lean_dec(x_27); -lean_ctor_set(x_26, 0, x_30); -return x_26; -} -else -{ -lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_31 = lean_ctor_get(x_26, 1); -lean_inc(x_31); -lean_dec(x_26); -x_32 = lean_ctor_get(x_27, 0); -lean_inc(x_32); -lean_dec(x_27); -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_32); -lean_ctor_set(x_33, 1, x_31); -return x_33; -} -} -else -{ -lean_object* x_34; lean_object* x_35; lean_object* x_36; -x_34 = lean_ctor_get(x_26, 1); -lean_inc(x_34); -lean_dec(x_26); -x_35 = lean_ctor_get(x_27, 0); +x_35 = lean_ctor_get(x_27, 1); lean_inc(x_35); lean_dec(x_27); -x_36 = lean_nat_add(x_6, x_8); -lean_dec(x_6); -x_5 = x_19; -x_6 = x_36; -x_9 = x_35; -x_14 = x_34; +x_36 = lean_ctor_get(x_28, 0); +lean_inc(x_36); +lean_dec(x_28); +x_37 = lean_nat_add(x_7, x_9); +lean_dec(x_7); +x_6 = x_20; +x_7 = x_37; +x_10 = x_36; +x_15 = x_35; goto _start; } } else { -uint8_t x_38; -lean_dec(x_19); +uint8_t x_39; +lean_dec(x_20); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); +lean_dec(x_7); +lean_dec(x_5); lean_dec(x_3); -x_38 = !lean_is_exclusive(x_26); -if (x_38 == 0) +x_39 = !lean_is_exclusive(x_27); +if (x_39 == 0) { -return x_26; +return x_27; } else { -lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_39 = lean_ctor_get(x_26, 0); -x_40 = lean_ctor_get(x_26, 1); +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_27, 0); +x_41 = lean_ctor_get(x_27, 1); +lean_inc(x_41); lean_inc(x_40); -lean_inc(x_39); -lean_dec(x_26); -x_41 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_41, 0, x_39); -lean_ctor_set(x_41, 1, x_40); -return x_41; +lean_dec(x_27); +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +return x_42; } } } else { -lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; -lean_inc(x_21); -x_42 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_42, 0, x_21); -x_43 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__14; -x_44 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_44, 0, x_43); -lean_ctor_set(x_44, 1, x_42); +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; +lean_inc(x_22); +x_43 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_43, 0, x_22); +x_44 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__14; x_45 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_45, 0, x_44); lean_ctor_set(x_45, 1, x_43); -x_46 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_22, x_45, x_10, x_11, x_12, x_13, x_24); -x_47 = lean_ctor_get(x_46, 0); -lean_inc(x_47); -x_48 = lean_ctor_get(x_46, 1); +x_46 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_46, 0, x_45); +lean_ctor_set(x_46, 1, x_44); +x_47 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_23, x_46, x_11, x_12, x_13, x_14, x_25); +x_48 = lean_ctor_get(x_47, 0); lean_inc(x_48); -lean_dec(x_46); +x_49 = lean_ctor_get(x_47, 1); +lean_inc(x_49); +lean_dec(x_47); +lean_inc(x_14); lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); -lean_inc(x_10); +lean_inc(x_5); lean_inc(x_3); -x_49 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(x_6, x_4, x_3, x_21, x_1, x_9, x_47, x_10, x_11, x_12, x_13, x_48); -lean_dec(x_47); -if (lean_obj_tag(x_49) == 0) -{ -lean_object* x_50; -x_50 = lean_ctor_get(x_49, 0); -lean_inc(x_50); +x_50 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(x_7, x_4, x_3, x_22, x_1, x_5, x_10, x_48, x_11, x_12, x_13, x_14, x_49); +lean_dec(x_48); if (lean_obj_tag(x_50) == 0) { -uint8_t x_51; -lean_dec(x_19); +lean_object* x_51; +x_51 = lean_ctor_get(x_50, 0); +lean_inc(x_51); +if (lean_obj_tag(x_51) == 0) +{ +uint8_t x_52; +lean_dec(x_20); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); +lean_dec(x_7); +lean_dec(x_5); lean_dec(x_3); -x_51 = !lean_is_exclusive(x_49); -if (x_51 == 0) +x_52 = !lean_is_exclusive(x_50); +if (x_52 == 0) { -lean_object* x_52; lean_object* x_53; -x_52 = lean_ctor_get(x_49, 0); -lean_dec(x_52); +lean_object* x_53; lean_object* x_54; x_53 = lean_ctor_get(x_50, 0); -lean_inc(x_53); -lean_dec(x_50); -lean_ctor_set(x_49, 0, x_53); -return x_49; +lean_dec(x_53); +x_54 = lean_ctor_get(x_51, 0); +lean_inc(x_54); +lean_dec(x_51); +lean_ctor_set(x_50, 0, x_54); +return x_50; } else { -lean_object* x_54; lean_object* x_55; lean_object* x_56; -x_54 = lean_ctor_get(x_49, 1); -lean_inc(x_54); -lean_dec(x_49); -x_55 = lean_ctor_get(x_50, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_50, 1); lean_inc(x_55); lean_dec(x_50); -x_56 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_56, 0, x_55); -lean_ctor_set(x_56, 1, x_54); -return x_56; +x_56 = lean_ctor_get(x_51, 0); +lean_inc(x_56); +lean_dec(x_51); +x_57 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_57, 0, x_56); +lean_ctor_set(x_57, 1, x_55); +return x_57; } } else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; -x_57 = lean_ctor_get(x_49, 1); -lean_inc(x_57); -lean_dec(x_49); -x_58 = lean_ctor_get(x_50, 0); +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_50, 1); lean_inc(x_58); lean_dec(x_50); -x_59 = lean_nat_add(x_6, x_8); -lean_dec(x_6); -x_5 = x_19; -x_6 = x_59; -x_9 = x_58; -x_14 = x_57; +x_59 = lean_ctor_get(x_51, 0); +lean_inc(x_59); +lean_dec(x_51); +x_60 = lean_nat_add(x_7, x_9); +lean_dec(x_7); +x_6 = x_20; +x_7 = x_60; +x_10 = x_59; +x_15 = x_58; goto _start; } } else { -uint8_t x_61; -lean_dec(x_19); +uint8_t x_62; +lean_dec(x_20); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_3); -x_61 = !lean_is_exclusive(x_49); -if (x_61 == 0) -{ -return x_49; -} -else -{ -lean_object* x_62; lean_object* x_63; lean_object* x_64; -x_62 = lean_ctor_get(x_49, 0); -x_63 = lean_ctor_get(x_49, 1); -lean_inc(x_63); -lean_inc(x_62); -lean_dec(x_49); -x_64 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_64, 0, x_62); -lean_ctor_set(x_64, 1, x_63); -return x_64; -} -} -} -} -} -else -{ -lean_object* x_77; -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); +lean_dec(x_7); lean_dec(x_5); lean_dec(x_3); -x_77 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_77, 0, x_9); -lean_ctor_set(x_77, 1, x_14); -return x_77; +x_62 = !lean_is_exclusive(x_50); +if (x_62 == 0) +{ +return x_50; +} +else +{ +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_50, 0); +x_64 = lean_ctor_get(x_50, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_50); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} } } else { lean_object* x_78; +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); +lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); x_78 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_78, 0, x_9); -lean_ctor_set(x_78, 1, x_14); +lean_ctor_set(x_78, 0, x_10); +lean_ctor_set(x_78, 1, x_15); return x_78; } } +else +{ +lean_object* x_79; +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +x_79 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_79, 0, x_10); +lean_ctor_set(x_79, 1, x_15); +return x_79; +} +} } static lean_object* _init_l_Lean_Elab_Structural_mkEqns___lambda__1___closed__1() { _start: @@ -2238,7 +2252,7 @@ lean_inc(x_2); x_16 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__1___rarg(x_10, x_2, x_3, x_4, x_5, x_6); if (lean_obj_tag(x_16) == 0) { -lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; x_17 = lean_ctor_get(x_16, 0); lean_inc(x_17); x_18 = lean_ctor_get(x_16, 1); @@ -2257,103 +2271,105 @@ x_23 = lean_ctor_get(x_7, 0); lean_inc(x_23); lean_inc(x_23); x_24 = l_Lean_mkPrivateName(x_22, x_23); -x_25 = lean_array_get_size(x_17); -x_26 = lean_unsigned_to_nat(0u); -x_27 = lean_unsigned_to_nat(1u); -x_28 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__2; -lean_inc(x_25); -x_29 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(x_7, x_17, x_23, x_24, x_25, x_26, x_25, x_27, x_28, x_2, x_3, x_4, x_5, x_21); -lean_dec(x_25); +x_25 = lean_box(0); +x_26 = lean_array_get_size(x_17); +x_27 = lean_unsigned_to_nat(0u); +x_28 = lean_unsigned_to_nat(1u); +x_29 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__2; +lean_inc(x_26); +x_30 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(x_7, x_17, x_23, x_24, x_25, x_26, x_27, x_26, x_28, x_29, x_2, x_3, x_4, x_5, x_21); +lean_dec(x_26); lean_dec(x_24); lean_dec(x_17); lean_dec(x_7); -if (lean_obj_tag(x_29) == 0) +if (lean_obj_tag(x_30) == 0) { -uint8_t x_30; -x_30 = !lean_is_exclusive(x_29); -if (x_30 == 0) +uint8_t x_31; +x_31 = !lean_is_exclusive(x_30); +if (x_31 == 0) { -return x_29; +return x_30; } else { -lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_31 = lean_ctor_get(x_29, 0); -x_32 = lean_ctor_get(x_29, 1); +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_30, 0); +x_33 = lean_ctor_get(x_30, 1); +lean_inc(x_33); lean_inc(x_32); -lean_inc(x_31); -lean_dec(x_29); -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_31); -lean_ctor_set(x_33, 1, x_32); -return x_33; +lean_dec(x_30); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +return x_34; } } else { -uint8_t x_34; -x_34 = !lean_is_exclusive(x_29); -if (x_34 == 0) +uint8_t x_35; +x_35 = !lean_is_exclusive(x_30); +if (x_35 == 0) { -return x_29; +return x_30; } else { -lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_35 = lean_ctor_get(x_29, 0); -x_36 = lean_ctor_get(x_29, 1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_30, 0); +x_37 = lean_ctor_get(x_30, 1); +lean_inc(x_37); lean_inc(x_36); -lean_inc(x_35); -lean_dec(x_29); -x_37 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_37, 0, x_35); -lean_ctor_set(x_37, 1, x_36); -return x_37; +lean_dec(x_30); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +return x_38; } } } else { -uint8_t x_38; +uint8_t x_39; lean_dec(x_4); lean_dec(x_7); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_38 = !lean_is_exclusive(x_16); -if (x_38 == 0) +x_39 = !lean_is_exclusive(x_16); +if (x_39 == 0) { return x_16; } else { -lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_39 = lean_ctor_get(x_16, 0); -x_40 = lean_ctor_get(x_16, 1); +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_16, 0); +x_41 = lean_ctor_get(x_16, 1); +lean_inc(x_41); lean_inc(x_40); -lean_inc(x_39); lean_dec(x_16); -x_41 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_41, 0, x_39); -lean_ctor_set(x_41, 1, x_40); -return x_41; +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +return x_42; } } } else { -lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_42 = lean_ctor_get(x_4, 0); -x_43 = lean_ctor_get(x_4, 1); -x_44 = lean_ctor_get(x_4, 2); -x_45 = lean_ctor_get(x_4, 3); -x_46 = lean_ctor_get(x_4, 4); -x_47 = lean_ctor_get(x_4, 5); -x_48 = lean_ctor_get(x_4, 6); -x_49 = lean_ctor_get(x_4, 7); -x_50 = lean_ctor_get(x_4, 8); -x_51 = lean_ctor_get(x_4, 9); -x_52 = lean_ctor_get(x_4, 10); +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_43 = lean_ctor_get(x_4, 0); +x_44 = lean_ctor_get(x_4, 1); +x_45 = lean_ctor_get(x_4, 2); +x_46 = lean_ctor_get(x_4, 3); +x_47 = lean_ctor_get(x_4, 4); +x_48 = lean_ctor_get(x_4, 5); +x_49 = lean_ctor_get(x_4, 6); +x_50 = lean_ctor_get(x_4, 7); +x_51 = lean_ctor_get(x_4, 8); +x_52 = lean_ctor_get(x_4, 9); +x_53 = lean_ctor_get(x_4, 10); +lean_inc(x_53); lean_inc(x_52); lean_inc(x_51); lean_inc(x_50); @@ -2364,163 +2380,163 @@ lean_inc(x_46); lean_inc(x_45); lean_inc(x_44); lean_inc(x_43); -lean_inc(x_42); lean_dec(x_4); -x_53 = l_Lean_Elab_Structural_mkEqns___closed__1; -x_54 = 0; -x_55 = l_Lean_Option_set___at_Lean_Meta_withPPInaccessibleNamesImp___spec__2(x_44, x_53, x_54); -x_56 = lean_alloc_ctor(0, 11, 0); -lean_ctor_set(x_56, 0, x_42); -lean_ctor_set(x_56, 1, x_43); -lean_ctor_set(x_56, 2, x_55); -lean_ctor_set(x_56, 3, x_45); -lean_ctor_set(x_56, 4, x_46); -lean_ctor_set(x_56, 5, x_47); -lean_ctor_set(x_56, 6, x_48); -lean_ctor_set(x_56, 7, x_49); -lean_ctor_set(x_56, 8, x_50); -lean_ctor_set(x_56, 9, x_51); -lean_ctor_set(x_56, 10, x_52); +x_54 = l_Lean_Elab_Structural_mkEqns___closed__1; +x_55 = 0; +x_56 = l_Lean_Option_set___at_Lean_Meta_withPPInaccessibleNamesImp___spec__2(x_45, x_54, x_55); +x_57 = lean_alloc_ctor(0, 11, 0); +lean_ctor_set(x_57, 0, x_43); +lean_ctor_set(x_57, 1, x_44); +lean_ctor_set(x_57, 2, x_56); +lean_ctor_set(x_57, 3, x_46); +lean_ctor_set(x_57, 4, x_47); +lean_ctor_set(x_57, 5, x_48); +lean_ctor_set(x_57, 6, x_49); +lean_ctor_set(x_57, 7, x_50); +lean_ctor_set(x_57, 8, x_51); +lean_ctor_set(x_57, 9, x_52); +lean_ctor_set(x_57, 10, x_53); lean_inc(x_5); -lean_inc(x_56); +lean_inc(x_57); lean_inc(x_3); lean_inc(x_2); -x_57 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__1___rarg(x_10, x_2, x_3, x_56, x_5, x_6); -if (lean_obj_tag(x_57) == 0) +x_58 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__1___rarg(x_10, x_2, x_3, x_57, x_5, x_6); +if (lean_obj_tag(x_58) == 0) { -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; -x_58 = lean_ctor_get(x_57, 0); -lean_inc(x_58); -x_59 = lean_ctor_get(x_57, 1); +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_59 = lean_ctor_get(x_58, 0); lean_inc(x_59); -lean_dec(x_57); -x_60 = lean_st_ref_get(x_5, x_59); -x_61 = lean_ctor_get(x_60, 0); -lean_inc(x_61); -x_62 = lean_ctor_get(x_60, 1); +x_60 = lean_ctor_get(x_58, 1); +lean_inc(x_60); +lean_dec(x_58); +x_61 = lean_st_ref_get(x_5, x_60); +x_62 = lean_ctor_get(x_61, 0); lean_inc(x_62); -lean_dec(x_60); -x_63 = lean_ctor_get(x_61, 0); +x_63 = lean_ctor_get(x_61, 1); lean_inc(x_63); lean_dec(x_61); -x_64 = lean_ctor_get(x_7, 0); +x_64 = lean_ctor_get(x_62, 0); lean_inc(x_64); -lean_inc(x_64); -x_65 = l_Lean_mkPrivateName(x_63, x_64); -x_66 = lean_array_get_size(x_58); -x_67 = lean_unsigned_to_nat(0u); -x_68 = lean_unsigned_to_nat(1u); -x_69 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__2; -lean_inc(x_66); -x_70 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(x_7, x_58, x_64, x_65, x_66, x_67, x_66, x_68, x_69, x_2, x_3, x_56, x_5, x_62); +lean_dec(x_62); +x_65 = lean_ctor_get(x_7, 0); +lean_inc(x_65); +lean_inc(x_65); +x_66 = l_Lean_mkPrivateName(x_64, x_65); +x_67 = lean_box(0); +x_68 = lean_array_get_size(x_59); +x_69 = lean_unsigned_to_nat(0u); +x_70 = lean_unsigned_to_nat(1u); +x_71 = l___private_Lean_Elab_PreDefinition_Structural_Eqns_0__Lean_Elab_Structural_mkProof_go___lambda__1___closed__2; +lean_inc(x_68); +x_72 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(x_7, x_59, x_65, x_66, x_67, x_68, x_69, x_68, x_70, x_71, x_2, x_3, x_57, x_5, x_63); +lean_dec(x_68); lean_dec(x_66); -lean_dec(x_65); -lean_dec(x_58); +lean_dec(x_59); lean_dec(x_7); -if (lean_obj_tag(x_70) == 0) +if (lean_obj_tag(x_72) == 0) { -lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; -x_71 = lean_ctor_get(x_70, 0); -lean_inc(x_71); -x_72 = lean_ctor_get(x_70, 1); -lean_inc(x_72); -if (lean_is_exclusive(x_70)) { - lean_ctor_release(x_70, 0); - lean_ctor_release(x_70, 1); - x_73 = x_70; +lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_73 = lean_ctor_get(x_72, 0); +lean_inc(x_73); +x_74 = lean_ctor_get(x_72, 1); +lean_inc(x_74); +if (lean_is_exclusive(x_72)) { + lean_ctor_release(x_72, 0); + lean_ctor_release(x_72, 1); + x_75 = x_72; } else { - lean_dec_ref(x_70); - x_73 = lean_box(0); + lean_dec_ref(x_72); + x_75 = lean_box(0); } -if (lean_is_scalar(x_73)) { - x_74 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_75)) { + x_76 = lean_alloc_ctor(0, 2, 0); } else { - x_74 = x_73; + x_76 = x_75; } -lean_ctor_set(x_74, 0, x_71); -lean_ctor_set(x_74, 1, x_72); -return x_74; +lean_ctor_set(x_76, 0, x_73); +lean_ctor_set(x_76, 1, x_74); +return x_76; } else { -lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; -x_75 = lean_ctor_get(x_70, 0); -lean_inc(x_75); -x_76 = lean_ctor_get(x_70, 1); -lean_inc(x_76); -if (lean_is_exclusive(x_70)) { - lean_ctor_release(x_70, 0); - lean_ctor_release(x_70, 1); - x_77 = x_70; +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; +x_77 = lean_ctor_get(x_72, 0); +lean_inc(x_77); +x_78 = lean_ctor_get(x_72, 1); +lean_inc(x_78); +if (lean_is_exclusive(x_72)) { + lean_ctor_release(x_72, 0); + lean_ctor_release(x_72, 1); + x_79 = x_72; } else { - lean_dec_ref(x_70); - x_77 = lean_box(0); + lean_dec_ref(x_72); + x_79 = lean_box(0); } -if (lean_is_scalar(x_77)) { - x_78 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_79)) { + x_80 = lean_alloc_ctor(1, 2, 0); } else { - x_78 = x_77; + x_80 = x_79; } -lean_ctor_set(x_78, 0, x_75); -lean_ctor_set(x_78, 1, x_76); -return x_78; +lean_ctor_set(x_80, 0, x_77); +lean_ctor_set(x_80, 1, x_78); +return x_80; } } else { -lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -lean_dec(x_56); +lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; +lean_dec(x_57); lean_dec(x_7); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_79 = lean_ctor_get(x_57, 0); -lean_inc(x_79); -x_80 = lean_ctor_get(x_57, 1); -lean_inc(x_80); -if (lean_is_exclusive(x_57)) { - lean_ctor_release(x_57, 0); - lean_ctor_release(x_57, 1); - x_81 = x_57; +x_81 = lean_ctor_get(x_58, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_58, 1); +lean_inc(x_82); +if (lean_is_exclusive(x_58)) { + lean_ctor_release(x_58, 0); + lean_ctor_release(x_58, 1); + x_83 = x_58; } else { - lean_dec_ref(x_57); - x_81 = lean_box(0); + lean_dec_ref(x_58); + x_83 = lean_box(0); } -if (lean_is_scalar(x_81)) { - x_82 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_83)) { + x_84 = lean_alloc_ctor(1, 2, 0); } else { - x_82 = x_81; + x_84 = x_83; } -lean_ctor_set(x_82, 0, x_79); -lean_ctor_set(x_82, 1, x_80); -return x_82; +lean_ctor_set(x_84, 0, x_81); +lean_ctor_set(x_84, 1, x_82); +return x_84; } } } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { _start: { -lean_object* x_13; -x_13 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12); -lean_dec(x_7); +lean_object* x_14; +x_14 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13); +lean_dec(x_8); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -return x_13; +return x_14; } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { _start: { -lean_object* x_15; -x_15 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14); +lean_object* x_16; +x_16 = l_Std_Range_forIn_loop___at_Lean_Elab_Structural_mkEqns___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15); +lean_dec(x_9); lean_dec(x_8); -lean_dec(x_7); lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); -return x_15; +return x_16; } } static lean_object* _init_l_Lean_Elab_Structural_initFn____x40_Lean_Elab_PreDefinition_Structural_Eqns___hyg_1069____closed__1() { diff --git a/stage0/stdlib/Lean/Elab/PreDefinition/WF/Eqns.c b/stage0/stdlib/Lean/Elab/PreDefinition/WF/Eqns.c index 49ce832edb..594c474bbf 100644 --- a/stage0/stdlib/Lean/Elab/PreDefinition/WF/Eqns.c +++ b/stage0/stdlib/Lean/Elab/PreDefinition/WF/Eqns.c @@ -16,7 +16,7 @@ extern "C" { static lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_mkProof_go___lambda__1___closed__5; LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_tryToFoldWellFoundedFix_pre(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___closed__2; -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_rwFixEq___lambda__1___closed__5; size_t lean_usize_add(size_t, size_t); LEAN_EXPORT lean_object* l_Array_isEqvAux___at_Lean_Elab_WF_simpMatchWF_x3f_pre___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -172,7 +172,7 @@ lean_object* l_Lean_Meta_matchMatcherApp_x3f___at_Lean_Meta_Simp_simpMatch_x3f__ lean_object* l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_assignExprMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_WF_simpMatchWF_x3f_pre___closed__2; -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_getFixedPrefix___lambda__2___closed__2; LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_mkProof_go___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_getFixedPrefix___lambda__3___closed__2; @@ -196,7 +196,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_WF_getUnfoldFor_x3f(lean_object*, lean_obje lean_object* l_Lean_Name_append(lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_getFixedPrefix(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_WF_initFn____x40_Lean_Elab_PreDefinition_WF_Eqns___hyg_2887____closed__1; -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static uint64_t l_Lean_Elab_WF_instInhabitedEqnInfo___closed__1; LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_mkProof_go___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_getFixedPrefix___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -282,7 +282,7 @@ lean_object* l_Lean_Meta_registerGetUnfoldEqnFn(lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_tryToFoldWellFoundedFix_pre___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Option_set___at_Lean_Meta_withPPInaccessibleNamesImp___spec__2(lean_object*, lean_object*, uint8_t); extern lean_object* l_Lean_Meta_Simp_defaultMaxSteps; -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_tryToFoldWellFoundedFix_pre___closed__9; lean_object* l_Lean_Meta_instInhabitedMetaM___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_tryToFoldWellFoundedFix(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -6268,453 +6268,467 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { _start: { -lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; -x_14 = lean_unsigned_to_nat(1u); -x_15 = lean_nat_add(x_1, x_14); -x_16 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___closed__2; -x_17 = lean_name_append_index_after(x_16, x_15); -x_18 = l_Lean_Name_append(x_2, x_17); -lean_inc(x_18); -x_19 = lean_array_push(x_7, x_18); +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; +x_15 = lean_unsigned_to_nat(1u); +x_16 = lean_nat_add(x_1, x_15); +x_17 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___closed__2; +x_18 = lean_name_append_index_after(x_17, x_16); +x_19 = l_Lean_Name_append(x_2, x_18); +lean_inc(x_19); +x_20 = lean_array_push(x_8, x_19); +lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); lean_inc(x_10); -lean_inc(x_9); lean_inc(x_5); -x_20 = l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_mkProof(x_3, x_4, x_5, x_9, x_10, x_11, x_12, x_13); -if (lean_obj_tag(x_20) == 0) +x_21 = l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_mkProof(x_3, x_4, x_5, x_10, x_11, x_12, x_13, x_14); +if (lean_obj_tag(x_21) == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; -x_21 = lean_ctor_get(x_20, 0); -lean_inc(x_21); -x_22 = lean_ctor_get(x_20, 1); +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_22 = lean_ctor_get(x_21, 0); lean_inc(x_22); -lean_dec(x_20); -x_23 = l_Lean_Elab_Eqns_removeUnusedEqnHypotheses(x_5, x_21, x_11, x_12, x_22); -x_24 = lean_ctor_get(x_23, 0); -lean_inc(x_24); -x_25 = lean_ctor_get(x_23, 1); +x_23 = lean_ctor_get(x_21, 1); +lean_inc(x_23); +lean_dec(x_21); +x_24 = l_Lean_Elab_Eqns_removeUnusedEqnHypotheses(x_5, x_22, x_12, x_13, x_23); +x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); -lean_dec(x_23); -x_26 = lean_ctor_get(x_24, 0); +x_26 = lean_ctor_get(x_24, 1); lean_inc(x_26); -x_27 = lean_ctor_get(x_24, 1); -lean_inc(x_27); lean_dec(x_24); -x_28 = lean_ctor_get(x_6, 1); +x_27 = lean_ctor_get(x_25, 0); +lean_inc(x_27); +x_28 = lean_ctor_get(x_25, 1); lean_inc(x_28); -x_29 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_29, 0, x_18); -lean_ctor_set(x_29, 1, x_28); -lean_ctor_set(x_29, 2, x_26); -x_30 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_30, 0, x_29); -lean_ctor_set(x_30, 1, x_27); -x_31 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_31, 0, x_30); -x_32 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_31, x_9, x_10, x_11, x_12, x_25); -if (lean_obj_tag(x_32) == 0) +lean_dec(x_25); +x_29 = lean_ctor_get(x_6, 1); +lean_inc(x_29); +lean_inc(x_19); +x_30 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_30, 0, x_19); +lean_ctor_set(x_30, 1, x_29); +lean_ctor_set(x_30, 2, x_27); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_19); +lean_ctor_set(x_31, 1, x_7); +x_32 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_32, 0, x_30); +lean_ctor_set(x_32, 1, x_28); +lean_ctor_set(x_32, 2, x_31); +x_33 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_33, x_10, x_11, x_12, x_13, x_26); +if (lean_obj_tag(x_34) == 0) { -uint8_t x_33; -x_33 = !lean_is_exclusive(x_32); -if (x_33 == 0) +uint8_t x_35; +x_35 = !lean_is_exclusive(x_34); +if (x_35 == 0) { -lean_object* x_34; lean_object* x_35; -x_34 = lean_ctor_get(x_32, 0); +lean_object* x_36; lean_object* x_37; +x_36 = lean_ctor_get(x_34, 0); +lean_dec(x_36); +x_37 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_37, 0, x_20); +lean_ctor_set(x_34, 0, x_37); +return x_34; +} +else +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_38 = lean_ctor_get(x_34, 1); +lean_inc(x_38); lean_dec(x_34); -x_35 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_35, 0, x_19); -lean_ctor_set(x_32, 0, x_35); -return x_32; +x_39 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_39, 0, x_20); +x_40 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_40, 0, x_39); +lean_ctor_set(x_40, 1, x_38); +return x_40; +} +} +else +{ +uint8_t x_41; +lean_dec(x_20); +x_41 = !lean_is_exclusive(x_34); +if (x_41 == 0) +{ +return x_34; +} +else +{ +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_34, 0); +x_43 = lean_ctor_get(x_34, 1); +lean_inc(x_43); +lean_inc(x_42); +lean_dec(x_34); +x_44 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_44, 0, x_42); +lean_ctor_set(x_44, 1, x_43); +return x_44; +} +} +} +else +{ +uint8_t x_45; +lean_dec(x_20); +lean_dec(x_19); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_7); +lean_dec(x_5); +x_45 = !lean_is_exclusive(x_21); +if (x_45 == 0) +{ +return x_21; +} +else +{ +lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_46 = lean_ctor_get(x_21, 0); +x_47 = lean_ctor_get(x_21, 1); +lean_inc(x_47); +lean_inc(x_46); +lean_dec(x_21); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_46); +lean_ctor_set(x_48, 1, x_47); +return x_48; +} +} +} +} +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { +_start: +{ +uint8_t x_17; +x_17 = lean_nat_dec_le(x_9, x_8); +if (x_17 == 0) +{ +lean_object* x_18; uint8_t x_19; +x_18 = lean_unsigned_to_nat(0u); +x_19 = lean_nat_dec_eq(x_7, x_18); +if (x_19 == 0) +{ +lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; lean_object* x_26; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; +x_20 = lean_unsigned_to_nat(1u); +x_21 = lean_nat_sub(x_7, x_20); +lean_dec(x_7); +x_22 = l_Lean_instInhabitedExpr; +x_23 = lean_array_get(x_22, x_5, x_8); +x_24 = l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_getFixedPrefix___lambda__2___closed__2; +x_68 = lean_st_ref_get(x_15, x_16); +x_69 = lean_ctor_get(x_68, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_69, 3); +lean_inc(x_70); +lean_dec(x_69); +x_71 = lean_ctor_get_uint8(x_70, sizeof(void*)*1); +lean_dec(x_70); +if (x_71 == 0) +{ +lean_object* x_72; uint8_t x_73; +x_72 = lean_ctor_get(x_68, 1); +lean_inc(x_72); +lean_dec(x_68); +x_73 = 0; +x_25 = x_73; +x_26 = x_72; +goto block_67; +} +else +{ +lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; +x_74 = lean_ctor_get(x_68, 1); +lean_inc(x_74); +lean_dec(x_68); +x_75 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_24, x_12, x_13, x_14, x_15, x_74); +x_76 = lean_ctor_get(x_75, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_75, 1); +lean_inc(x_77); +lean_dec(x_75); +x_78 = lean_unbox(x_76); +lean_dec(x_76); +x_25 = x_78; +x_26 = x_77; +goto block_67; +} +block_67: +{ +if (x_25 == 0) +{ +lean_object* x_27; lean_object* x_28; +x_27 = lean_box(0); +lean_inc(x_15); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_inc(x_6); +lean_inc(x_2); +lean_inc(x_1); +x_28 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(x_8, x_3, x_1, x_2, x_23, x_4, x_6, x_11, x_27, x_12, x_13, x_14, x_15, x_26); +if (lean_obj_tag(x_28) == 0) +{ +lean_object* x_29; +x_29 = lean_ctor_get(x_28, 0); +lean_inc(x_29); +if (lean_obj_tag(x_29) == 0) +{ +uint8_t x_30; +lean_dec(x_21); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_30 = !lean_is_exclusive(x_28); +if (x_30 == 0) +{ +lean_object* x_31; lean_object* x_32; +x_31 = lean_ctor_get(x_28, 0); +lean_dec(x_31); +x_32 = lean_ctor_get(x_29, 0); +lean_inc(x_32); +lean_dec(x_29); +lean_ctor_set(x_28, 0, x_32); +return x_28; +} +else +{ +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_28, 1); +lean_inc(x_33); +lean_dec(x_28); +x_34 = lean_ctor_get(x_29, 0); +lean_inc(x_34); +lean_dec(x_29); +x_35 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_35, 0, x_34); +lean_ctor_set(x_35, 1, x_33); +return x_35; +} } else { lean_object* x_36; lean_object* x_37; lean_object* x_38; -x_36 = lean_ctor_get(x_32, 1); -lean_inc(x_36); -lean_dec(x_32); -x_37 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_37, 0, x_19); -x_38 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_38, 0, x_37); -lean_ctor_set(x_38, 1, x_36); -return x_38; -} -} -else -{ -uint8_t x_39; -lean_dec(x_19); -x_39 = !lean_is_exclusive(x_32); -if (x_39 == 0) -{ -return x_32; -} -else -{ -lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_40 = lean_ctor_get(x_32, 0); -x_41 = lean_ctor_get(x_32, 1); -lean_inc(x_41); -lean_inc(x_40); -lean_dec(x_32); -x_42 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_42, 0, x_40); -lean_ctor_set(x_42, 1, x_41); -return x_42; -} -} -} -else -{ -uint8_t x_43; -lean_dec(x_19); -lean_dec(x_18); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_5); -x_43 = !lean_is_exclusive(x_20); -if (x_43 == 0) -{ -return x_20; -} -else -{ -lean_object* x_44; lean_object* x_45; lean_object* x_46; -x_44 = lean_ctor_get(x_20, 0); -x_45 = lean_ctor_get(x_20, 1); -lean_inc(x_45); -lean_inc(x_44); -lean_dec(x_20); -x_46 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_46, 0, x_44); -lean_ctor_set(x_46, 1, x_45); -return x_46; -} -} -} -} -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { -_start: -{ -uint8_t x_16; -x_16 = lean_nat_dec_le(x_8, x_7); -if (x_16 == 0) -{ -lean_object* x_17; uint8_t x_18; -x_17 = lean_unsigned_to_nat(0u); -x_18 = lean_nat_dec_eq(x_6, x_17); -if (x_18 == 0) -{ -lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; lean_object* x_25; lean_object* x_67; lean_object* x_68; lean_object* x_69; uint8_t x_70; -x_19 = lean_unsigned_to_nat(1u); -x_20 = lean_nat_sub(x_6, x_19); -lean_dec(x_6); -x_21 = l_Lean_instInhabitedExpr; -x_22 = lean_array_get(x_21, x_5, x_7); -x_23 = l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_getFixedPrefix___lambda__2___closed__2; -x_67 = lean_st_ref_get(x_14, x_15); -x_68 = lean_ctor_get(x_67, 0); -lean_inc(x_68); -x_69 = lean_ctor_get(x_68, 3); -lean_inc(x_69); -lean_dec(x_68); -x_70 = lean_ctor_get_uint8(x_69, sizeof(void*)*1); -lean_dec(x_69); -if (x_70 == 0) -{ -lean_object* x_71; uint8_t x_72; -x_71 = lean_ctor_get(x_67, 1); -lean_inc(x_71); -lean_dec(x_67); -x_72 = 0; -x_24 = x_72; -x_25 = x_71; -goto block_66; -} -else -{ -lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; uint8_t x_77; -x_73 = lean_ctor_get(x_67, 1); -lean_inc(x_73); -lean_dec(x_67); -x_74 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_23, x_11, x_12, x_13, x_14, x_73); -x_75 = lean_ctor_get(x_74, 0); -lean_inc(x_75); -x_76 = lean_ctor_get(x_74, 1); -lean_inc(x_76); -lean_dec(x_74); -x_77 = lean_unbox(x_75); -lean_dec(x_75); -x_24 = x_77; -x_25 = x_76; -goto block_66; -} -block_66: -{ -if (x_24 == 0) -{ -lean_object* x_26; lean_object* x_27; -x_26 = lean_box(0); -lean_inc(x_14); -lean_inc(x_13); -lean_inc(x_12); -lean_inc(x_11); -lean_inc(x_2); -lean_inc(x_1); -x_27 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(x_7, x_3, x_1, x_2, x_22, x_4, x_10, x_26, x_11, x_12, x_13, x_14, x_25); -if (lean_obj_tag(x_27) == 0) -{ -lean_object* x_28; -x_28 = lean_ctor_get(x_27, 0); -lean_inc(x_28); -if (lean_obj_tag(x_28) == 0) -{ -uint8_t x_29; -lean_dec(x_20); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_7); -lean_dec(x_2); -lean_dec(x_1); -x_29 = !lean_is_exclusive(x_27); -if (x_29 == 0) -{ -lean_object* x_30; lean_object* x_31; -x_30 = lean_ctor_get(x_27, 0); -lean_dec(x_30); -x_31 = lean_ctor_get(x_28, 0); -lean_inc(x_31); -lean_dec(x_28); -lean_ctor_set(x_27, 0, x_31); -return x_27; -} -else -{ -lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_32 = lean_ctor_get(x_27, 1); -lean_inc(x_32); -lean_dec(x_27); -x_33 = lean_ctor_get(x_28, 0); -lean_inc(x_33); -lean_dec(x_28); -x_34 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_34, 0, x_33); -lean_ctor_set(x_34, 1, x_32); -return x_34; -} -} -else -{ -lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_35 = lean_ctor_get(x_27, 1); -lean_inc(x_35); -lean_dec(x_27); -x_36 = lean_ctor_get(x_28, 0); +x_36 = lean_ctor_get(x_28, 1); lean_inc(x_36); lean_dec(x_28); -x_37 = lean_nat_add(x_7, x_9); -lean_dec(x_7); -x_6 = x_20; -x_7 = x_37; -x_10 = x_36; -x_15 = x_35; +x_37 = lean_ctor_get(x_29, 0); +lean_inc(x_37); +lean_dec(x_29); +x_38 = lean_nat_add(x_8, x_10); +lean_dec(x_8); +x_7 = x_21; +x_8 = x_38; +x_11 = x_37; +x_16 = x_36; goto _start; } } else { -uint8_t x_39; -lean_dec(x_20); +uint8_t x_40; +lean_dec(x_21); +lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); -x_39 = !lean_is_exclusive(x_27); -if (x_39 == 0) +x_40 = !lean_is_exclusive(x_28); +if (x_40 == 0) { -return x_27; +return x_28; } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_40 = lean_ctor_get(x_27, 0); -x_41 = lean_ctor_get(x_27, 1); +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_28, 0); +x_42 = lean_ctor_get(x_28, 1); +lean_inc(x_42); lean_inc(x_41); -lean_inc(x_40); -lean_dec(x_27); -x_42 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_42, 0, x_40); -lean_ctor_set(x_42, 1, x_41); -return x_42; +lean_dec(x_28); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +return x_43; } } } else { -lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; -lean_inc(x_22); -x_43 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_43, 0, x_22); -x_44 = l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_tryToFoldWellFoundedFix_pre___closed__10; -x_45 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_45, 0, x_44); -lean_ctor_set(x_45, 1, x_43); +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +lean_inc(x_23); +x_44 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_44, 0, x_23); +x_45 = l___private_Lean_Elab_PreDefinition_WF_Eqns_0__Lean_Elab_WF_tryToFoldWellFoundedFix_pre___closed__10; x_46 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_46, 0, x_45); lean_ctor_set(x_46, 1, x_44); -x_47 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_23, x_46, x_11, x_12, x_13, x_14, x_25); -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); +x_47 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_45); +x_48 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_24, x_47, x_12, x_13, x_14, x_15, x_26); +x_49 = lean_ctor_get(x_48, 0); lean_inc(x_49); -lean_dec(x_47); +x_50 = lean_ctor_get(x_48, 1); +lean_inc(x_50); +lean_dec(x_48); +lean_inc(x_15); lean_inc(x_14); lean_inc(x_13); lean_inc(x_12); -lean_inc(x_11); +lean_inc(x_6); lean_inc(x_2); lean_inc(x_1); -x_50 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(x_7, x_3, x_1, x_2, x_22, x_4, x_10, x_48, x_11, x_12, x_13, x_14, x_49); -lean_dec(x_48); -if (lean_obj_tag(x_50) == 0) -{ -lean_object* x_51; -x_51 = lean_ctor_get(x_50, 0); -lean_inc(x_51); +x_51 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(x_8, x_3, x_1, x_2, x_23, x_4, x_6, x_11, x_49, x_12, x_13, x_14, x_15, x_50); +lean_dec(x_49); if (lean_obj_tag(x_51) == 0) { -uint8_t x_52; -lean_dec(x_20); +lean_object* x_52; +x_52 = lean_ctor_get(x_51, 0); +lean_inc(x_52); +if (lean_obj_tag(x_52) == 0) +{ +uint8_t x_53; +lean_dec(x_21); +lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); -x_52 = !lean_is_exclusive(x_50); -if (x_52 == 0) +x_53 = !lean_is_exclusive(x_51); +if (x_53 == 0) { -lean_object* x_53; lean_object* x_54; -x_53 = lean_ctor_get(x_50, 0); -lean_dec(x_53); +lean_object* x_54; lean_object* x_55; x_54 = lean_ctor_get(x_51, 0); -lean_inc(x_54); -lean_dec(x_51); -lean_ctor_set(x_50, 0, x_54); -return x_50; +lean_dec(x_54); +x_55 = lean_ctor_get(x_52, 0); +lean_inc(x_55); +lean_dec(x_52); +lean_ctor_set(x_51, 0, x_55); +return x_51; } else { -lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_55 = lean_ctor_get(x_50, 1); -lean_inc(x_55); -lean_dec(x_50); -x_56 = lean_ctor_get(x_51, 0); +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_51, 1); lean_inc(x_56); lean_dec(x_51); -x_57 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_57, 0, x_56); -lean_ctor_set(x_57, 1, x_55); -return x_57; +x_57 = lean_ctor_get(x_52, 0); +lean_inc(x_57); +lean_dec(x_52); +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_57); +lean_ctor_set(x_58, 1, x_56); +return x_58; } } else { -lean_object* x_58; lean_object* x_59; lean_object* x_60; -x_58 = lean_ctor_get(x_50, 1); -lean_inc(x_58); -lean_dec(x_50); -x_59 = lean_ctor_get(x_51, 0); +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_51, 1); lean_inc(x_59); lean_dec(x_51); -x_60 = lean_nat_add(x_7, x_9); -lean_dec(x_7); -x_6 = x_20; -x_7 = x_60; -x_10 = x_59; -x_15 = x_58; +x_60 = lean_ctor_get(x_52, 0); +lean_inc(x_60); +lean_dec(x_52); +x_61 = lean_nat_add(x_8, x_10); +lean_dec(x_8); +x_7 = x_21; +x_8 = x_61; +x_11 = x_60; +x_16 = x_59; goto _start; } } else { -uint8_t x_62; -lean_dec(x_20); +uint8_t x_63; +lean_dec(x_21); +lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_7); -lean_dec(x_2); -lean_dec(x_1); -x_62 = !lean_is_exclusive(x_50); -if (x_62 == 0) -{ -return x_50; -} -else -{ -lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_63 = lean_ctor_get(x_50, 0); -x_64 = lean_ctor_get(x_50, 1); -lean_inc(x_64); -lean_inc(x_63); -lean_dec(x_50); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_63); -lean_ctor_set(x_65, 1, x_64); -return x_65; -} -} -} -} -} -else -{ -lean_object* x_78; -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_7); +lean_dec(x_8); lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); -x_78 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_78, 0, x_10); -lean_ctor_set(x_78, 1, x_15); -return x_78; +x_63 = !lean_is_exclusive(x_51); +if (x_63 == 0) +{ +return x_51; +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_51, 0); +x_65 = lean_ctor_get(x_51, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_51); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; +} +} +} } } else { lean_object* x_79; +lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); -lean_dec(x_11); +lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); x_79 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_79, 0, x_10); -lean_ctor_set(x_79, 1, x_15); +lean_ctor_set(x_79, 0, x_11); +lean_ctor_set(x_79, 1, x_16); return x_79; } } +else +{ +lean_object* x_80; +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_2); +lean_dec(x_1); +x_80 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_80, 0, x_11); +lean_ctor_set(x_80, 1, x_16); +return x_80; +} +} } LEAN_EXPORT lean_object* l_Lean_Elab_WF_mkEqns___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10) { _start: @@ -6838,70 +6852,71 @@ lean_inc(x_3); x_22 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__1___rarg(x_21, x_3, x_4, x_5, x_6, x_15); if (lean_obj_tag(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; lean_object* x_29; +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; x_23 = lean_ctor_get(x_22, 0); lean_inc(x_23); x_24 = lean_ctor_get(x_22, 1); lean_inc(x_24); lean_dec(x_22); -x_25 = lean_array_get_size(x_23); -x_26 = lean_unsigned_to_nat(0u); -x_27 = lean_unsigned_to_nat(1u); -x_28 = l_Lean_Elab_WF_instInhabitedEqnInfo___closed__4; -lean_inc(x_25); -x_29 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(x_1, x_2, x_17, x_18, x_23, x_25, x_26, x_25, x_27, x_28, x_3, x_4, x_5, x_6, x_24); -lean_dec(x_25); +x_25 = lean_box(0); +x_26 = lean_array_get_size(x_23); +x_27 = lean_unsigned_to_nat(0u); +x_28 = lean_unsigned_to_nat(1u); +x_29 = l_Lean_Elab_WF_instInhabitedEqnInfo___closed__4; +lean_inc(x_26); +x_30 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(x_1, x_2, x_17, x_18, x_23, x_25, x_26, x_27, x_26, x_28, x_29, x_3, x_4, x_5, x_6, x_24); +lean_dec(x_26); lean_dec(x_23); lean_dec(x_18); lean_dec(x_17); -if (lean_obj_tag(x_29) == 0) +if (lean_obj_tag(x_30) == 0) { -uint8_t x_30; -x_30 = !lean_is_exclusive(x_29); -if (x_30 == 0) +uint8_t x_31; +x_31 = !lean_is_exclusive(x_30); +if (x_31 == 0) { -return x_29; +return x_30; } else { -lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_31 = lean_ctor_get(x_29, 0); -x_32 = lean_ctor_get(x_29, 1); +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_30, 0); +x_33 = lean_ctor_get(x_30, 1); +lean_inc(x_33); lean_inc(x_32); -lean_inc(x_31); -lean_dec(x_29); -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_31); -lean_ctor_set(x_33, 1, x_32); -return x_33; +lean_dec(x_30); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_32); +lean_ctor_set(x_34, 1, x_33); +return x_34; } } else { -uint8_t x_34; -x_34 = !lean_is_exclusive(x_29); -if (x_34 == 0) +uint8_t x_35; +x_35 = !lean_is_exclusive(x_30); +if (x_35 == 0) { -return x_29; +return x_30; } else { -lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_35 = lean_ctor_get(x_29, 0); -x_36 = lean_ctor_get(x_29, 1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_30, 0); +x_37 = lean_ctor_get(x_30, 1); +lean_inc(x_37); lean_inc(x_36); -lean_inc(x_35); -lean_dec(x_29); -x_37 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_37, 0, x_35); -lean_ctor_set(x_37, 1, x_36); -return x_37; +lean_dec(x_30); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +return x_38; } } } else { -uint8_t x_38; +uint8_t x_39; lean_dec(x_18); lean_dec(x_17); lean_dec(x_5); @@ -6910,40 +6925,41 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_38 = !lean_is_exclusive(x_22); -if (x_38 == 0) +x_39 = !lean_is_exclusive(x_22); +if (x_39 == 0) { return x_22; } else { -lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_39 = lean_ctor_get(x_22, 0); -x_40 = lean_ctor_get(x_22, 1); +lean_object* x_40; lean_object* x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_22, 0); +x_41 = lean_ctor_get(x_22, 1); +lean_inc(x_41); lean_inc(x_40); -lean_inc(x_39); lean_dec(x_22); -x_41 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_41, 0, x_39); -lean_ctor_set(x_41, 1, x_40); -return x_41; +x_42 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_42, 0, x_40); +lean_ctor_set(x_42, 1, x_41); +return x_42; } } } else { -lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; -x_42 = lean_ctor_get(x_5, 0); -x_43 = lean_ctor_get(x_5, 1); -x_44 = lean_ctor_get(x_5, 2); -x_45 = lean_ctor_get(x_5, 3); -x_46 = lean_ctor_get(x_5, 4); -x_47 = lean_ctor_get(x_5, 5); -x_48 = lean_ctor_get(x_5, 6); -x_49 = lean_ctor_get(x_5, 7); -x_50 = lean_ctor_get(x_5, 8); -x_51 = lean_ctor_get(x_5, 9); -x_52 = lean_ctor_get(x_5, 10); +lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_43 = lean_ctor_get(x_5, 0); +x_44 = lean_ctor_get(x_5, 1); +x_45 = lean_ctor_get(x_5, 2); +x_46 = lean_ctor_get(x_5, 3); +x_47 = lean_ctor_get(x_5, 4); +x_48 = lean_ctor_get(x_5, 5); +x_49 = lean_ctor_get(x_5, 6); +x_50 = lean_ctor_get(x_5, 7); +x_51 = lean_ctor_get(x_5, 8); +x_52 = lean_ctor_get(x_5, 9); +x_53 = lean_ctor_get(x_5, 10); +lean_inc(x_53); lean_inc(x_52); lean_inc(x_51); lean_inc(x_50); @@ -6954,178 +6970,178 @@ lean_inc(x_46); lean_inc(x_45); lean_inc(x_44); lean_inc(x_43); -lean_inc(x_42); lean_dec(x_5); -x_53 = l_Lean_Elab_WF_mkEqns___closed__1; -x_54 = 0; -x_55 = l_Lean_Option_set___at_Lean_Meta_withPPInaccessibleNamesImp___spec__2(x_44, x_53, x_54); -x_56 = lean_alloc_ctor(0, 11, 0); -lean_ctor_set(x_56, 0, x_42); -lean_ctor_set(x_56, 1, x_43); -lean_ctor_set(x_56, 2, x_55); -lean_ctor_set(x_56, 3, x_45); -lean_ctor_set(x_56, 4, x_46); -lean_ctor_set(x_56, 5, x_47); -lean_ctor_set(x_56, 6, x_48); -lean_ctor_set(x_56, 7, x_49); -lean_ctor_set(x_56, 8, x_50); -lean_ctor_set(x_56, 9, x_51); -lean_ctor_set(x_56, 10, x_52); -x_57 = lean_st_ref_get(x_6, x_7); -x_58 = lean_ctor_get(x_57, 0); -lean_inc(x_58); -x_59 = lean_ctor_get(x_57, 1); +x_54 = l_Lean_Elab_WF_mkEqns___closed__1; +x_55 = 0; +x_56 = l_Lean_Option_set___at_Lean_Meta_withPPInaccessibleNamesImp___spec__2(x_45, x_54, x_55); +x_57 = lean_alloc_ctor(0, 11, 0); +lean_ctor_set(x_57, 0, x_43); +lean_ctor_set(x_57, 1, x_44); +lean_ctor_set(x_57, 2, x_56); +lean_ctor_set(x_57, 3, x_46); +lean_ctor_set(x_57, 4, x_47); +lean_ctor_set(x_57, 5, x_48); +lean_ctor_set(x_57, 6, x_49); +lean_ctor_set(x_57, 7, x_50); +lean_ctor_set(x_57, 8, x_51); +lean_ctor_set(x_57, 9, x_52); +lean_ctor_set(x_57, 10, x_53); +x_58 = lean_st_ref_get(x_6, x_7); +x_59 = lean_ctor_get(x_58, 0); lean_inc(x_59); -lean_dec(x_57); -x_60 = lean_ctor_get(x_58, 0); +x_60 = lean_ctor_get(x_58, 1); lean_inc(x_60); lean_dec(x_58); +x_61 = lean_ctor_get(x_59, 0); +lean_inc(x_61); +lean_dec(x_59); lean_inc(x_1); -x_61 = l_Lean_mkPrivateName(x_60, x_1); -x_62 = lean_ctor_get(x_2, 0); -lean_inc(x_62); -x_63 = lean_ctor_get(x_62, 3); +x_62 = l_Lean_mkPrivateName(x_61, x_1); +x_63 = lean_ctor_get(x_2, 0); lean_inc(x_63); +x_64 = lean_ctor_get(x_63, 3); +lean_inc(x_64); lean_inc(x_2); lean_inc(x_1); -lean_inc(x_62); -x_64 = lean_alloc_closure((void*)(l_Lean_Elab_WF_mkEqns___lambda__1), 10, 3); -lean_closure_set(x_64, 0, x_62); -lean_closure_set(x_64, 1, x_1); -lean_closure_set(x_64, 2, x_2); -x_65 = lean_alloc_closure((void*)(l_Lean_Meta_lambdaTelescope___at___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___spec__5___rarg), 7, 2); +lean_inc(x_63); +x_65 = lean_alloc_closure((void*)(l_Lean_Elab_WF_mkEqns___lambda__1), 10, 3); lean_closure_set(x_65, 0, x_63); -lean_closure_set(x_65, 1, x_64); +lean_closure_set(x_65, 1, x_1); +lean_closure_set(x_65, 2, x_2); +x_66 = lean_alloc_closure((void*)(l_Lean_Meta_lambdaTelescope___at___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___spec__5___rarg), 7, 2); +lean_closure_set(x_66, 0, x_64); +lean_closure_set(x_66, 1, x_65); lean_inc(x_6); -lean_inc(x_56); +lean_inc(x_57); lean_inc(x_4); lean_inc(x_3); -x_66 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__1___rarg(x_65, x_3, x_4, x_56, x_6, x_59); -if (lean_obj_tag(x_66) == 0) +x_67 = l_Lean_Meta_withNewMCtxDepth___at___private_Lean_Meta_WHNF_0__Lean_Meta_toCtorWhenK___spec__1___rarg(x_66, x_3, x_4, x_57, x_6, x_60); +if (lean_obj_tag(x_67) == 0) { -lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; -x_67 = lean_ctor_get(x_66, 0); -lean_inc(x_67); -x_68 = lean_ctor_get(x_66, 1); +lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; +x_68 = lean_ctor_get(x_67, 0); lean_inc(x_68); -lean_dec(x_66); -x_69 = lean_array_get_size(x_67); -x_70 = lean_unsigned_to_nat(0u); -x_71 = lean_unsigned_to_nat(1u); -x_72 = l_Lean_Elab_WF_instInhabitedEqnInfo___closed__4; +x_69 = lean_ctor_get(x_67, 1); lean_inc(x_69); -x_73 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(x_1, x_2, x_61, x_62, x_67, x_69, x_70, x_69, x_71, x_72, x_3, x_4, x_56, x_6, x_68); -lean_dec(x_69); lean_dec(x_67); +x_70 = lean_box(0); +x_71 = lean_array_get_size(x_68); +x_72 = lean_unsigned_to_nat(0u); +x_73 = lean_unsigned_to_nat(1u); +x_74 = l_Lean_Elab_WF_instInhabitedEqnInfo___closed__4; +lean_inc(x_71); +x_75 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(x_1, x_2, x_62, x_63, x_68, x_70, x_71, x_72, x_71, x_73, x_74, x_3, x_4, x_57, x_6, x_69); +lean_dec(x_71); +lean_dec(x_68); +lean_dec(x_63); lean_dec(x_62); -lean_dec(x_61); -if (lean_obj_tag(x_73) == 0) +if (lean_obj_tag(x_75) == 0) { -lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; -x_74 = lean_ctor_get(x_73, 0); -lean_inc(x_74); -x_75 = lean_ctor_get(x_73, 1); -lean_inc(x_75); -if (lean_is_exclusive(x_73)) { - lean_ctor_release(x_73, 0); - lean_ctor_release(x_73, 1); - x_76 = x_73; +lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; +x_76 = lean_ctor_get(x_75, 0); +lean_inc(x_76); +x_77 = lean_ctor_get(x_75, 1); +lean_inc(x_77); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + lean_ctor_release(x_75, 1); + x_78 = x_75; } else { - lean_dec_ref(x_73); - x_76 = lean_box(0); + lean_dec_ref(x_75); + x_78 = lean_box(0); } -if (lean_is_scalar(x_76)) { - x_77 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_78)) { + x_79 = lean_alloc_ctor(0, 2, 0); } else { - x_77 = x_76; + x_79 = x_78; } -lean_ctor_set(x_77, 0, x_74); -lean_ctor_set(x_77, 1, x_75); -return x_77; +lean_ctor_set(x_79, 0, x_76); +lean_ctor_set(x_79, 1, x_77); +return x_79; } else { -lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; -x_78 = lean_ctor_get(x_73, 0); -lean_inc(x_78); -x_79 = lean_ctor_get(x_73, 1); -lean_inc(x_79); -if (lean_is_exclusive(x_73)) { - lean_ctor_release(x_73, 0); - lean_ctor_release(x_73, 1); - x_80 = x_73; +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_80 = lean_ctor_get(x_75, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_75, 1); +lean_inc(x_81); +if (lean_is_exclusive(x_75)) { + lean_ctor_release(x_75, 0); + lean_ctor_release(x_75, 1); + x_82 = x_75; } else { - lean_dec_ref(x_73); - x_80 = lean_box(0); + lean_dec_ref(x_75); + x_82 = lean_box(0); } -if (lean_is_scalar(x_80)) { - x_81 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(1, 2, 0); } else { - x_81 = x_80; + x_83 = x_82; } -lean_ctor_set(x_81, 0, x_78); -lean_ctor_set(x_81, 1, x_79); -return x_81; +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); +return x_83; } } else { -lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; +lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; +lean_dec(x_63); lean_dec(x_62); -lean_dec(x_61); -lean_dec(x_56); +lean_dec(x_57); lean_dec(x_6); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_82 = lean_ctor_get(x_66, 0); -lean_inc(x_82); -x_83 = lean_ctor_get(x_66, 1); -lean_inc(x_83); -if (lean_is_exclusive(x_66)) { - lean_ctor_release(x_66, 0); - lean_ctor_release(x_66, 1); - x_84 = x_66; +x_84 = lean_ctor_get(x_67, 0); +lean_inc(x_84); +x_85 = lean_ctor_get(x_67, 1); +lean_inc(x_85); +if (lean_is_exclusive(x_67)) { + lean_ctor_release(x_67, 0); + lean_ctor_release(x_67, 1); + x_86 = x_67; } else { - lean_dec_ref(x_66); - x_84 = lean_box(0); + lean_dec_ref(x_67); + x_86 = lean_box(0); } -if (lean_is_scalar(x_84)) { - x_85 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_86)) { + x_87 = lean_alloc_ctor(1, 2, 0); } else { - x_85 = x_84; + x_87 = x_86; } -lean_ctor_set(x_85, 0, x_82); -lean_ctor_set(x_85, 1, x_83); -return x_85; +lean_ctor_set(x_87, 0, x_84); +lean_ctor_set(x_87, 1, x_85); +return x_87; } } } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { _start: { -lean_object* x_14; -x_14 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13); -lean_dec(x_8); +lean_object* x_15; +x_15 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14); +lean_dec(x_9); lean_dec(x_6); lean_dec(x_2); lean_dec(x_1); -return x_14; +return x_15; } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { _start: { -lean_object* x_16; -x_16 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15); +lean_object* x_17; +x_17 = l_Std_Range_forIn_loop___at_Lean_Elab_WF_mkEqns___spec__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16); +lean_dec(x_10); lean_dec(x_9); -lean_dec(x_8); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -return x_16; +return x_17; } } static lean_object* _init_l_Lean_Elab_WF_initFn____x40_Lean_Elab_PreDefinition_WF_Eqns___hyg_2887____closed__1() { diff --git a/stage0/stdlib/Lean/Elab/Print.c b/stage0/stdlib/Lean/Elab/Print.c index f847dc8f53..f73c02e4ee 100644 --- a/stage0/stdlib/Lean/Elab/Print.c +++ b/stage0/stdlib/Lean/Elab/Print.c @@ -1958,7 +1958,7 @@ x_20 = lean_ctor_get(x_19, 0); lean_inc(x_20); x_21 = lean_ctor_get(x_19, 1); lean_inc(x_21); -x_22 = lean_ctor_get_uint8(x_19, sizeof(void*)*3); +x_22 = lean_ctor_get_uint8(x_19, sizeof(void*)*4); lean_dec(x_19); x_23 = lean_ctor_get(x_20, 1); lean_inc(x_23); @@ -2000,7 +2000,7 @@ lean_inc(x_35); lean_dec(x_11); x_36 = lean_ctor_get(x_35, 0); lean_inc(x_36); -x_37 = lean_ctor_get_uint8(x_35, sizeof(void*)*2); +x_37 = lean_ctor_get_uint8(x_35, sizeof(void*)*3); lean_dec(x_35); x_38 = lean_ctor_get(x_36, 1); lean_inc(x_38); diff --git a/stage0/stdlib/Lean/Elab/Structure.c b/stage0/stdlib/Lean/Elab/Structure.c index 521c19c698..147bdf30c6 100644 --- a/stage0/stdlib/Lean/Elab/Structure.c +++ b/stage0/stdlib/Lean/Elab/Structure.c @@ -238,7 +238,7 @@ static lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_Structure static lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_getFieldType___lambda__5___closed__1; static lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_reprStructFieldKind____x40_Lean_Elab_Structure___hyg_327____closed__19; LEAN_EXPORT lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_Structure_0__Lean_Elab_Command_elabStructureView___spec__7___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_withFields_go___rarg___closed__10; uint8_t lean_usize_dec_lt(size_t, size_t); lean_object* l_liftExcept___at_Lean_Elab_liftMacroM___spec__1(lean_object*, lean_object*, lean_object*); @@ -576,7 +576,7 @@ static lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_reprStr lean_object* l_instBEqProd___rarg(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_addTrace___at___private_Lean_Elab_Term_0__Lean_Elab_Term_postponeElabTerm___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_reprStructFieldInfo____x40_Lean_Elab_Structure___hyg_522____closed__26; -LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_addMacroScope(lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_withParents_go___rarg___closed__1; static lean_object* l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_Structure_0__Lean_Elab_Command_expandFields___spec__5___closed__5; @@ -23448,453 +23448,465 @@ return x_7; } } } -LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, uint8_t x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, uint8_t x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { _start: { -lean_object* x_15; lean_object* x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; lean_object* x_20; -x_15 = l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_Structure_0__Lean_Elab_Command_expandFields___spec__5___closed__4; -lean_inc(x_9); -x_16 = lean_array_push(x_15, x_9); -x_17 = 0; -x_18 = 1; +lean_object* x_16; lean_object* x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; lean_object* x_21; +x_16 = l_Array_foldlMUnsafe_fold___at___private_Lean_Elab_Structure_0__Lean_Elab_Command_expandFields___spec__5___closed__4; +lean_inc(x_10); +x_17 = lean_array_push(x_16, x_10); +x_18 = 0; x_19 = 1; +x_20 = 1; lean_inc(x_1); -lean_inc(x_16); -x_20 = l_Lean_Meta_mkForallFVars(x_16, x_1, x_17, x_18, x_19, x_10, x_11, x_12, x_13, x_14); -if (lean_obj_tag(x_20) == 0) +lean_inc(x_17); +x_21 = l_Lean_Meta_mkForallFVars(x_17, x_1, x_18, x_19, x_20, x_11, x_12, x_13, x_14, x_15); +if (lean_obj_tag(x_21) == 0) { -lean_object* x_21; lean_object* x_22; lean_object* x_23; -x_21 = lean_ctor_get(x_20, 0); -lean_inc(x_21); -x_22 = lean_ctor_get(x_20, 1); +lean_object* x_22; lean_object* x_23; lean_object* x_24; +x_22 = lean_ctor_get(x_21, 0); lean_inc(x_22); -lean_dec(x_20); +x_23 = lean_ctor_get(x_21, 1); +lean_inc(x_23); +lean_dec(x_21); lean_inc(x_2); -x_23 = l_Lean_Meta_mkForallFVars(x_2, x_21, x_17, x_18, x_19, x_10, x_11, x_12, x_13, x_22); -if (lean_obj_tag(x_23) == 0) +x_24 = l_Lean_Meta_mkForallFVars(x_2, x_22, x_18, x_19, x_20, x_11, x_12, x_13, x_14, x_23); +if (lean_obj_tag(x_24) == 0) { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; -x_24 = lean_ctor_get(x_23, 0); -lean_inc(x_24); -x_25 = lean_ctor_get(x_23, 1); +lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; +x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); -lean_dec(x_23); -lean_inc(x_11); -x_26 = l_Lean_Meta_instantiateMVars(x_24, x_10, x_11, x_12, x_13, x_25); -x_27 = lean_ctor_get(x_26, 0); -lean_inc(x_27); -x_28 = lean_ctor_get(x_26, 1); +x_26 = lean_ctor_get(x_24, 1); +lean_inc(x_26); +lean_dec(x_24); +lean_inc(x_12); +x_27 = l_Lean_Meta_instantiateMVars(x_25, x_11, x_12, x_13, x_14, x_26); +x_28 = lean_ctor_get(x_27, 0); lean_inc(x_28); -lean_dec(x_26); -x_29 = lean_array_get_size(x_2); -x_30 = l_Lean_Expr_inferImplicit(x_27, x_29, x_18); -lean_dec(x_29); +x_29 = lean_ctor_get(x_27, 1); +lean_inc(x_29); +lean_dec(x_27); +x_30 = lean_array_get_size(x_2); +x_31 = l_Lean_Expr_inferImplicit(x_28, x_30, x_19); +lean_dec(x_30); +lean_inc(x_14); lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); -lean_inc(x_10); lean_inc(x_1); lean_inc(x_3); -x_31 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent_copyFields(x_3, x_4, x_9, x_1, x_10, x_11, x_12, x_13, x_28); -if (lean_obj_tag(x_31) == 0) +x_32 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent_copyFields(x_3, x_4, x_10, x_1, x_11, x_12, x_13, x_14, x_29); +if (lean_obj_tag(x_32) == 0) { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_32 = lean_ctor_get(x_31, 0); -lean_inc(x_32); -x_33 = lean_ctor_get(x_31, 1); +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_32, 0); lean_inc(x_33); -lean_dec(x_31); -x_34 = l_Lean_Meta_mkLambdaFVars(x_16, x_32, x_17, x_18, x_19, x_10, x_11, x_12, x_13, x_33); -if (lean_obj_tag(x_34) == 0) +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +lean_dec(x_32); +x_35 = l_Lean_Meta_mkLambdaFVars(x_17, x_33, x_18, x_19, x_20, x_11, x_12, x_13, x_14, x_34); +if (lean_obj_tag(x_35) == 0) { -lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); -x_36 = lean_ctor_get(x_34, 1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_35, 0); lean_inc(x_36); -lean_dec(x_34); -x_37 = l_Lean_Meta_mkLambdaFVars(x_2, x_35, x_17, x_18, x_19, x_10, x_11, x_12, x_13, x_36); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 1); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Meta_mkLambdaFVars(x_2, x_36, x_18, x_19, x_20, x_11, x_12, x_13, x_14, x_37); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -x_39 = lean_ctor_get(x_37, 1); +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_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -lean_dec(x_37); -lean_inc(x_11); -x_40 = l_Lean_Meta_instantiateMVars(x_38, x_10, x_11, x_12, x_13, x_39); -x_41 = lean_ctor_get(x_40, 0); -lean_inc(x_41); -x_42 = lean_ctor_get(x_40, 1); +x_40 = lean_ctor_get(x_38, 1); +lean_inc(x_40); +lean_dec(x_38); +lean_inc(x_12); +x_41 = l_Lean_Meta_instantiateMVars(x_39, x_11, x_12, x_13, x_14, x_40); +x_42 = lean_ctor_get(x_41, 0); lean_inc(x_42); -lean_dec(x_40); -x_43 = l_Lean_Meta_getStructureName(x_1, x_10, x_11, x_12, x_13, x_42); -if (lean_obj_tag(x_43) == 0) -{ -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); -lean_inc(x_45); -lean_dec(x_43); -lean_inc(x_5); -x_46 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__1___boxed), 3, 2); -lean_closure_set(x_46, 0, x_5); -lean_closure_set(x_46, 1, x_3); -x_47 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkToParentName(x_44, x_46); -x_48 = l_Lean_Name_append(x_5, x_47); -lean_dec(x_5); -lean_inc(x_48); -x_49 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_49, 0, x_48); -lean_ctor_set(x_49, 1, x_6); -lean_ctor_set(x_49, 2, x_30); -x_50 = lean_ctor_get(x_7, 1); -x_51 = lean_ctor_get_uint8(x_50, sizeof(void*)*2 + 3); -if (x_51 == 0) -{ -lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; -x_52 = lean_box(1); -x_53 = 1; -x_54 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_54, 0, x_49); -lean_ctor_set(x_54, 1, x_41); -lean_ctor_set(x_54, 2, x_52); -lean_ctor_set_uint8(x_54, sizeof(void*)*3, x_53); -x_55 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_55, 0, x_54); -lean_inc(x_13); -lean_inc(x_12); -lean_inc(x_11); -lean_inc(x_10); -x_56 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_55, x_10, x_11, x_12, x_13, x_45); -if (lean_obj_tag(x_56) == 0) -{ -lean_object* x_57; uint8_t x_58; -x_57 = lean_ctor_get(x_56, 1); -lean_inc(x_57); -lean_dec(x_56); -x_58 = l_Lean_BinderInfo_isInstImplicit(x_8); -if (x_58 == 0) -{ -uint8_t x_59; lean_object* x_60; -x_59 = 0; -x_60 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_48, x_59, x_10, x_11, x_12, x_13, x_57); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -return x_60; -} -else -{ -uint8_t x_61; lean_object* x_62; lean_object* x_63; -x_61 = 0; -x_62 = lean_unsigned_to_nat(1000u); -x_63 = l_Lean_Meta_addInstance(x_48, x_61, x_62, x_10, x_11, x_12, x_13, x_57); -return x_63; -} -} -else -{ -uint8_t x_64; -lean_dec(x_48); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -x_64 = !lean_is_exclusive(x_56); -if (x_64 == 0) -{ -return x_56; -} -else -{ -lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_65 = lean_ctor_get(x_56, 0); -x_66 = lean_ctor_get(x_56, 1); -lean_inc(x_66); -lean_inc(x_65); -lean_dec(x_56); -x_67 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_67, 0, x_65); -lean_ctor_set(x_67, 1, x_66); -return x_67; -} -} -} -else -{ -lean_object* x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; -x_68 = lean_box(1); -x_69 = 0; -x_70 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_70, 0, x_49); -lean_ctor_set(x_70, 1, x_41); -lean_ctor_set(x_70, 2, x_68); -lean_ctor_set_uint8(x_70, sizeof(void*)*3, x_69); -x_71 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_71, 0, x_70); -lean_inc(x_13); -lean_inc(x_12); -lean_inc(x_11); -lean_inc(x_10); -x_72 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_71, x_10, x_11, x_12, x_13, x_45); -if (lean_obj_tag(x_72) == 0) -{ -lean_object* x_73; uint8_t x_74; -x_73 = lean_ctor_get(x_72, 1); -lean_inc(x_73); -lean_dec(x_72); -x_74 = l_Lean_BinderInfo_isInstImplicit(x_8); -if (x_74 == 0) -{ -uint8_t x_75; lean_object* x_76; -x_75 = 0; -x_76 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_48, x_75, x_10, x_11, x_12, x_13, x_73); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -return x_76; -} -else -{ -uint8_t x_77; lean_object* x_78; lean_object* x_79; -x_77 = 0; -x_78 = lean_unsigned_to_nat(1000u); -x_79 = l_Lean_Meta_addInstance(x_48, x_77, x_78, x_10, x_11, x_12, x_13, x_73); -return x_79; -} -} -else -{ -uint8_t x_80; -lean_dec(x_48); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -x_80 = !lean_is_exclusive(x_72); -if (x_80 == 0) -{ -return x_72; -} -else -{ -lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_81 = lean_ctor_get(x_72, 0); -x_82 = lean_ctor_get(x_72, 1); -lean_inc(x_82); -lean_inc(x_81); -lean_dec(x_72); -x_83 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_83, 0, x_81); -lean_ctor_set(x_83, 1, x_82); -return x_83; -} -} -} -} -else -{ -uint8_t x_84; +x_43 = lean_ctor_get(x_41, 1); +lean_inc(x_43); lean_dec(x_41); -lean_dec(x_30); +x_44 = l_Lean_Meta_getStructureName(x_1, x_11, x_12, x_13, x_14, x_43); +if (lean_obj_tag(x_44) == 0) +{ +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; +x_45 = lean_ctor_get(x_44, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +lean_inc(x_5); +x_47 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__1___boxed), 3, 2); +lean_closure_set(x_47, 0, x_5); +lean_closure_set(x_47, 1, x_3); +x_48 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkToParentName(x_45, x_47); +x_49 = l_Lean_Name_append(x_5, x_48); +lean_dec(x_5); +lean_inc(x_49); +x_50 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_6); +lean_ctor_set(x_50, 2, x_31); +x_51 = lean_ctor_get(x_7, 1); +x_52 = lean_ctor_get_uint8(x_51, sizeof(void*)*2 + 3); +lean_inc(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_49); +lean_ctor_set(x_53, 1, x_8); +if (x_52 == 0) +{ +lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_54 = lean_box(1); +x_55 = 1; +x_56 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_56, 0, x_50); +lean_ctor_set(x_56, 1, x_42); +lean_ctor_set(x_56, 2, x_54); +lean_ctor_set(x_56, 3, x_53); +lean_ctor_set_uint8(x_56, sizeof(void*)*4, x_55); +x_57 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_57, 0, x_56); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_inc(x_11); +x_58 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_57, x_11, x_12, x_13, x_14, x_46); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; uint8_t x_60; +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = l_Lean_BinderInfo_isInstImplicit(x_9); +if (x_60 == 0) +{ +uint8_t x_61; lean_object* x_62; +x_61 = 0; +x_62 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_49, x_61, x_11, x_12, x_13, x_14, x_59); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_3); -x_84 = !lean_is_exclusive(x_43); -if (x_84 == 0) -{ -return x_43; +return x_62; } else { -lean_object* x_85; lean_object* x_86; lean_object* x_87; -x_85 = lean_ctor_get(x_43, 0); -x_86 = lean_ctor_get(x_43, 1); -lean_inc(x_86); -lean_inc(x_85); -lean_dec(x_43); -x_87 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_87, 0, x_85); -lean_ctor_set(x_87, 1, x_86); -return x_87; -} +uint8_t x_63; lean_object* x_64; lean_object* x_65; +x_63 = 0; +x_64 = lean_unsigned_to_nat(1000u); +x_65 = l_Lean_Meta_addInstance(x_49, x_63, x_64, x_11, x_12, x_13, x_14, x_59); +return x_65; } } else { -uint8_t x_88; -lean_dec(x_30); +uint8_t x_66; +lean_dec(x_49); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_3); -lean_dec(x_1); -x_88 = !lean_is_exclusive(x_37); -if (x_88 == 0) +x_66 = !lean_is_exclusive(x_58); +if (x_66 == 0) { -return x_37; +return x_58; } else { -lean_object* x_89; lean_object* x_90; lean_object* x_91; -x_89 = lean_ctor_get(x_37, 0); -x_90 = lean_ctor_get(x_37, 1); -lean_inc(x_90); -lean_inc(x_89); -lean_dec(x_37); -x_91 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_91, 0, x_89); -lean_ctor_set(x_91, 1, x_90); -return x_91; +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_58, 0); +x_68 = lean_ctor_get(x_58, 1); +lean_inc(x_68); +lean_inc(x_67); +lean_dec(x_58); +x_69 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_69, 0, x_67); +lean_ctor_set(x_69, 1, x_68); +return x_69; } } } else { -uint8_t x_92; -lean_dec(x_30); +lean_object* x_70; uint8_t x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_70 = lean_box(1); +x_71 = 0; +x_72 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_72, 0, x_50); +lean_ctor_set(x_72, 1, x_42); +lean_ctor_set(x_72, 2, x_70); +lean_ctor_set(x_72, 3, x_53); +lean_ctor_set_uint8(x_72, sizeof(void*)*4, x_71); +x_73 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_73, 0, x_72); +lean_inc(x_14); +lean_inc(x_13); +lean_inc(x_12); +lean_inc(x_11); +x_74 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_73, x_11, x_12, x_13, x_14, x_46); +if (lean_obj_tag(x_74) == 0) +{ +lean_object* x_75; uint8_t x_76; +x_75 = lean_ctor_get(x_74, 1); +lean_inc(x_75); +lean_dec(x_74); +x_76 = l_Lean_BinderInfo_isInstImplicit(x_9); +if (x_76 == 0) +{ +uint8_t x_77; lean_object* x_78; +x_77 = 0; +x_78 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_49, x_77, x_11, x_12, x_13, x_14, x_75); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_3); -lean_dec(x_2); -lean_dec(x_1); -x_92 = !lean_is_exclusive(x_34); -if (x_92 == 0) -{ -return x_34; +return x_78; } else { -lean_object* x_93; lean_object* x_94; lean_object* x_95; -x_93 = lean_ctor_get(x_34, 0); -x_94 = lean_ctor_get(x_34, 1); -lean_inc(x_94); -lean_inc(x_93); -lean_dec(x_34); -x_95 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_95, 0, x_93); -lean_ctor_set(x_95, 1, x_94); -return x_95; -} +uint8_t x_79; lean_object* x_80; lean_object* x_81; +x_79 = 0; +x_80 = lean_unsigned_to_nat(1000u); +x_81 = l_Lean_Meta_addInstance(x_49, x_79, x_80, x_11, x_12, x_13, x_14, x_75); +return x_81; } } else { -uint8_t x_96; -lean_dec(x_30); -lean_dec(x_16); +uint8_t x_82; +lean_dec(x_49); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_3); -lean_dec(x_2); -lean_dec(x_1); -x_96 = !lean_is_exclusive(x_31); -if (x_96 == 0) +x_82 = !lean_is_exclusive(x_74); +if (x_82 == 0) { -return x_31; +return x_74; } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; -x_97 = lean_ctor_get(x_31, 0); -x_98 = lean_ctor_get(x_31, 1); -lean_inc(x_98); -lean_inc(x_97); +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_74, 0); +x_84 = lean_ctor_get(x_74, 1); +lean_inc(x_84); +lean_inc(x_83); +lean_dec(x_74); +x_85 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_85, 0, x_83); +lean_ctor_set(x_85, 1, x_84); +return x_85; +} +} +} +} +else +{ +uint8_t x_86; +lean_dec(x_42); lean_dec(x_31); -x_99 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_99, 0, x_97); -lean_ctor_set(x_99, 1, x_98); -return x_99; +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +x_86 = !lean_is_exclusive(x_44); +if (x_86 == 0) +{ +return x_44; +} +else +{ +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_44, 0); +x_88 = lean_ctor_get(x_44, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_44); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +return x_89; } } } else { -uint8_t x_100; -lean_dec(x_16); +uint8_t x_90; +lean_dec(x_31); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_1); +x_90 = !lean_is_exclusive(x_38); +if (x_90 == 0) +{ +return x_38; +} +else +{ +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_38, 0); +x_92 = lean_ctor_get(x_38, 1); +lean_inc(x_92); +lean_inc(x_91); +lean_dec(x_38); +x_93 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set(x_93, 1, x_92); +return x_93; +} +} +} +else +{ +uint8_t x_94; +lean_dec(x_31); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_94 = !lean_is_exclusive(x_35); +if (x_94 == 0) +{ +return x_35; +} +else +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; +x_95 = lean_ctor_get(x_35, 0); +x_96 = lean_ctor_get(x_35, 1); +lean_inc(x_96); +lean_inc(x_95); +lean_dec(x_35); +x_97 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_97, 0, x_95); +lean_ctor_set(x_97, 1, x_96); +return x_97; +} +} +} +else +{ +uint8_t x_98; +lean_dec(x_31); +lean_dec(x_17); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_98 = !lean_is_exclusive(x_32); +if (x_98 == 0) +{ +return x_32; +} +else +{ +lean_object* x_99; lean_object* x_100; lean_object* x_101; +x_99 = lean_ctor_get(x_32, 0); +x_100 = lean_ctor_get(x_32, 1); +lean_inc(x_100); +lean_inc(x_99); +lean_dec(x_32); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_100); +return x_101; +} +} +} +else +{ +uint8_t x_102; +lean_dec(x_17); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); +lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_100 = !lean_is_exclusive(x_23); -if (x_100 == 0) +x_102 = !lean_is_exclusive(x_24); +if (x_102 == 0) { -return x_23; +return x_24; } else { -lean_object* x_101; lean_object* x_102; lean_object* x_103; -x_101 = lean_ctor_get(x_23, 0); -x_102 = lean_ctor_get(x_23, 1); -lean_inc(x_102); -lean_inc(x_101); -lean_dec(x_23); -x_103 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_103, 0, x_101); -lean_ctor_set(x_103, 1, x_102); -return x_103; +lean_object* x_103; lean_object* x_104; lean_object* x_105; +x_103 = lean_ctor_get(x_24, 0); +x_104 = lean_ctor_get(x_24, 1); +lean_inc(x_104); +lean_inc(x_103); +lean_dec(x_24); +x_105 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_105, 0, x_103); +lean_ctor_set(x_105, 1, x_104); +return x_105; } } } else { -uint8_t x_104; -lean_dec(x_16); +uint8_t x_106; +lean_dec(x_17); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); +lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_104 = !lean_is_exclusive(x_20); -if (x_104 == 0) +x_106 = !lean_is_exclusive(x_21); +if (x_106 == 0) { -return x_20; +return x_21; } else { -lean_object* x_105; lean_object* x_106; lean_object* x_107; -x_105 = lean_ctor_get(x_20, 0); -x_106 = lean_ctor_get(x_20, 1); -lean_inc(x_106); -lean_inc(x_105); -lean_dec(x_20); -x_107 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_107, 0, x_105); -lean_ctor_set(x_107, 1, x_106); -return x_107; +lean_object* x_107; lean_object* x_108; lean_object* x_109; +x_107 = lean_ctor_get(x_21, 0); +x_108 = lean_ctor_get(x_21, 1); +lean_inc(x_108); +lean_inc(x_107); +lean_dec(x_21); +x_109 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_109, 0, x_107); +lean_ctor_set(x_109, 1, x_108); +return x_109; } } } @@ -23975,7 +23987,7 @@ uint8_t x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_obje lean_dec(x_21); x_23 = 0; x_24 = lean_box(x_23); -x_25 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed), 14, 8); +x_25 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed), 15, 9); lean_closure_set(x_25, 0, x_4); lean_closure_set(x_25, 1, x_2); lean_closure_set(x_25, 2, x_13); @@ -23983,7 +23995,8 @@ lean_closure_set(x_25, 3, x_16); lean_closure_set(x_25, 4, x_14); lean_closure_set(x_25, 5, x_1); lean_closure_set(x_25, 6, x_3); -lean_closure_set(x_25, 7, x_24); +lean_closure_set(x_25, 7, x_17); +lean_closure_set(x_25, 8, x_24); x_26 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___closed__4; x_27 = l_Lean_Meta_withLocalDecl___at_Lean_Meta_GeneralizeTelescope_generalizeTelescopeAux___spec__1___rarg(x_26, x_23, x_20, x_25, x_5, x_6, x_7, x_8, x_12); return x_27; @@ -24001,7 +24014,7 @@ if (x_29 == 0) uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; x_30 = 0; x_31 = lean_box(x_30); -x_32 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed), 14, 8); +x_32 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed), 15, 9); lean_closure_set(x_32, 0, x_4); lean_closure_set(x_32, 1, x_2); lean_closure_set(x_32, 2, x_13); @@ -24009,7 +24022,8 @@ lean_closure_set(x_32, 3, x_16); lean_closure_set(x_32, 4, x_14); lean_closure_set(x_32, 5, x_1); lean_closure_set(x_32, 6, x_3); -lean_closure_set(x_32, 7, x_31); +lean_closure_set(x_32, 7, x_17); +lean_closure_set(x_32, 8, x_31); x_33 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___closed__4; x_34 = l_Lean_Meta_withLocalDecl___at_Lean_Meta_GeneralizeTelescope_generalizeTelescopeAux___spec__1___rarg(x_33, x_30, x_20, x_32, x_5, x_6, x_7, x_8, x_12); return x_34; @@ -24019,7 +24033,7 @@ else uint8_t x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; x_35 = 3; x_36 = lean_box(x_35); -x_37 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed), 14, 8); +x_37 = lean_alloc_closure((void*)(l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed), 15, 9); lean_closure_set(x_37, 0, x_4); lean_closure_set(x_37, 1, x_2); lean_closure_set(x_37, 2, x_13); @@ -24027,7 +24041,8 @@ lean_closure_set(x_37, 3, x_16); lean_closure_set(x_37, 4, x_14); lean_closure_set(x_37, 5, x_1); lean_closure_set(x_37, 6, x_3); -lean_closure_set(x_37, 7, x_36); +lean_closure_set(x_37, 7, x_17); +lean_closure_set(x_37, 8, x_36); x_38 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___closed__4; x_39 = l_Lean_Meta_withLocalDecl___at_Lean_Meta_GeneralizeTelescope_generalizeTelescopeAux___spec__1___rarg(x_38, x_35, x_20, x_37, x_5, x_6, x_7, x_8, x_12); return x_39; @@ -24062,15 +24077,15 @@ x_5 = lean_box(x_4); return x_5; } } -LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +LEAN_EXPORT lean_object* l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { _start: { -uint8_t x_15; lean_object* x_16; -x_15 = lean_unbox(x_8); -lean_dec(x_8); -x_16 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_15, x_9, x_10, x_11, x_12, x_13, x_14); +uint8_t x_16; lean_object* x_17; +x_16 = lean_unbox(x_9); +lean_dec(x_9); +x_17 = l___private_Lean_Elab_Structure_0__Lean_Elab_Command_mkCoercionToCopiedParent___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_16, x_10, x_11, x_12, x_13, x_14, x_15); lean_dec(x_7); -return x_16; +return x_17; } } LEAN_EXPORT lean_object* l_List_mapTRAux___at___private_Lean_Elab_Structure_0__Lean_Elab_Command_elabStructureView___spec__1(lean_object* x_1, lean_object* x_2) { diff --git a/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c b/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c index bdd3e31b2a..7c67958a3a 100644 --- a/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c +++ b/stage0/stdlib/Lean/Elab/Tactic/ElabTerm.c @@ -10267,7 +10267,7 @@ lean_inc(x_4); x_11 = l_Lean_Elab_Term_mkAuxName(x_1, x_4, x_5, x_6, x_7, x_8, x_9, x_10); if (lean_obj_tag(x_11) == 0) { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; x_12 = lean_ctor_get(x_11, 0); lean_inc(x_12); x_13 = lean_ctor_get(x_11, 1); @@ -10279,82 +10279,87 @@ x_15 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_15, 0, x_12); lean_ctor_set(x_15, 1, x_14); lean_ctor_set(x_15, 2, x_2); -x_16 = lean_box(1); -x_17 = 1; -x_18 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_18, 0, x_15); -lean_ctor_set(x_18, 1, x_3); -lean_ctor_set(x_18, 2, x_16); -lean_ctor_set_uint8(x_18, sizeof(void*)*3, x_17); -x_19 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_19, 0, x_18); +lean_inc(x_12); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_12); +lean_ctor_set(x_16, 1, x_14); +x_17 = lean_box(1); +x_18 = 1; +x_19 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_19, 0, x_15); +lean_ctor_set(x_19, 1, x_3); +lean_ctor_set(x_19, 2, x_17); +lean_ctor_set(x_19, 3, x_16); +lean_ctor_set_uint8(x_19, sizeof(void*)*4, x_18); +x_20 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_20, 0, x_19); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); lean_inc(x_4); -lean_inc(x_19); -x_20 = l_Lean_addDecl___at_Lean_Elab_Term_evalExpr___spec__2(x_19, x_4, x_5, x_6, x_7, x_8, x_9, x_13); -if (lean_obj_tag(x_20) == 0) +lean_inc(x_20); +x_21 = l_Lean_addDecl___at_Lean_Elab_Term_evalExpr___spec__2(x_20, x_4, x_5, x_6, x_7, x_8, x_9, x_13); +if (lean_obj_tag(x_21) == 0) { -lean_object* x_21; lean_object* x_22; -x_21 = lean_ctor_get(x_20, 1); -lean_inc(x_21); -lean_dec(x_20); -x_22 = l_Lean_compileDecl___at_Lean_Elab_Term_evalExpr___spec__5(x_19, x_4, x_5, x_6, x_7, x_8, x_9, x_21); -if (lean_obj_tag(x_22) == 0) +lean_object* x_22; lean_object* x_23; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_compileDecl___at_Lean_Elab_Term_evalExpr___spec__5(x_20, x_4, x_5, x_6, x_7, x_8, x_9, x_22); +if (lean_obj_tag(x_23) == 0) { -uint8_t x_23; -x_23 = !lean_is_exclusive(x_22); -if (x_23 == 0) +uint8_t x_24; +x_24 = !lean_is_exclusive(x_23); +if (x_24 == 0) { -lean_object* x_24; -x_24 = lean_ctor_get(x_22, 0); -lean_dec(x_24); -lean_ctor_set(x_22, 0, x_12); -return x_22; +lean_object* x_25; +x_25 = lean_ctor_get(x_23, 0); +lean_dec(x_25); +lean_ctor_set(x_23, 0, x_12); +return x_23; } else { -lean_object* x_25; lean_object* x_26; -x_25 = lean_ctor_get(x_22, 1); -lean_inc(x_25); -lean_dec(x_22); -x_26 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_26, 0, x_12); -lean_ctor_set(x_26, 1, x_25); -return x_26; +lean_object* x_26; lean_object* x_27; +x_26 = lean_ctor_get(x_23, 1); +lean_inc(x_26); +lean_dec(x_23); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_12); +lean_ctor_set(x_27, 1, x_26); +return x_27; } } else { -uint8_t x_27; +uint8_t x_28; lean_dec(x_12); -x_27 = !lean_is_exclusive(x_22); -if (x_27 == 0) +x_28 = !lean_is_exclusive(x_23); +if (x_28 == 0) { -return x_22; +return x_23; } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; -x_28 = lean_ctor_get(x_22, 0); -x_29 = lean_ctor_get(x_22, 1); +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_23, 0); +x_30 = lean_ctor_get(x_23, 1); +lean_inc(x_30); lean_inc(x_29); -lean_inc(x_28); -lean_dec(x_22); -x_30 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_30, 0, x_28); -lean_ctor_set(x_30, 1, x_29); -return x_30; +lean_dec(x_23); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; } } } else { -uint8_t x_31; -lean_dec(x_19); +uint8_t x_32; +lean_dec(x_20); lean_dec(x_12); lean_dec(x_9); lean_dec(x_8); @@ -10362,29 +10367,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -x_31 = !lean_is_exclusive(x_20); -if (x_31 == 0) +x_32 = !lean_is_exclusive(x_21); +if (x_32 == 0) { -return x_20; +return x_21; } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_32 = lean_ctor_get(x_20, 0); -x_33 = lean_ctor_get(x_20, 1); +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_21, 0); +x_34 = lean_ctor_get(x_21, 1); +lean_inc(x_34); lean_inc(x_33); -lean_inc(x_32); -lean_dec(x_20); -x_34 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_34, 0, x_32); -lean_ctor_set(x_34, 1, x_33); -return x_34; +lean_dec(x_21); +x_35 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_35, 0, x_33); +lean_ctor_set(x_35, 1, x_34); +return x_35; } } } else { -uint8_t x_35; +uint8_t x_36; lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); @@ -10393,23 +10398,23 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_35 = !lean_is_exclusive(x_11); -if (x_35 == 0) +x_36 = !lean_is_exclusive(x_11); +if (x_36 == 0) { return x_11; } else { -lean_object* x_36; lean_object* x_37; lean_object* x_38; -x_36 = lean_ctor_get(x_11, 0); -x_37 = lean_ctor_get(x_11, 1); +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_11, 0); +x_38 = lean_ctor_get(x_11, 1); +lean_inc(x_38); lean_inc(x_37); -lean_inc(x_36); lean_dec(x_11); -x_38 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_38, 0, x_36); -lean_ctor_set(x_38, 1, x_37); -return x_38; +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +return x_39; } } } diff --git a/stage0/stdlib/Lean/Elab/Term.c b/stage0/stdlib/Lean/Elab/Term.c index 0dfb1e4800..c801675bc7 100644 --- a/stage0/stdlib/Lean/Elab/Term.c +++ b/stage0/stdlib/Lean/Elab/Term.c @@ -636,6 +636,7 @@ static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryCoeSort___la LEAN_EXPORT lean_object* l_Lean_Elab_mkDeclName___at_Lean_Elab_Term_expandDeclId___spec__2___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getId(lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_addMacroStack___at_Lean_Elab_Term_instAddErrorMessageContextTermElabM___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__1; static lean_object* l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__22; static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryCoeSort___lambda__1___closed__9; extern lean_object* l_Lean_Expr_instHashableExpr; @@ -644,7 +645,6 @@ static lean_object* l_Lean_Elab_Term_mkTermElabAttributeUnsafe___closed__6; LEAN_EXPORT lean_object* l_Lean_Elab_applyVisibility___at_Lean_Elab_Term_expandDeclId___spec__5(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_mkTypeMismatchError(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_throwPostpone___at_Lean_Elab_Term_tryPostpone___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__1; lean_object* lean_format_pretty(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_State_levelNames___default; LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Term_synthesizeInst___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -1102,7 +1102,6 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Term_logUnassignedUsingErrorInfos(lean_obje LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_mkSyntheticSorryFor___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Tactic_instInhabitedState; LEAN_EXPORT lean_object* l_ReaderT_map___at_Lean_Elab_Term_instMetaEvalTermElabM___spec__7(lean_object*, lean_object*); -static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__2; uint8_t l_Lean_Syntax_isOfKind(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_tryPostponeIfHasMVars_x3f___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_useImplicitLambda_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -1118,6 +1117,7 @@ LEAN_EXPORT lean_object* l_Lean_Elab_Term_throwTypeMismatchError___rarg(lean_obj LEAN_EXPORT lean_object* l_Lean_Elab_Term_addDotCompletionInfo___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Expr_instBEqExpr; LEAN_EXPORT lean_object* l_Lean_Elab_withSaveInfoContext___at_Lean_Elab_Term_withoutModifyingElabMetaStateWithInfo___spec__1(lean_object*); +static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__2; static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabTermAux___closed__2; LEAN_EXPORT lean_object* l_Lean_Elab_Term_ContainsPendingMVar_visit(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Elab_Term_mkExplicitBinder___closed__4; @@ -1165,7 +1165,7 @@ lean_object* l_IO_println___at_Lean_instEval___spec__1(lean_object*, lean_object static lean_object* l_Lean_Elab_Tactic_instInhabitedSnapshot___closed__17; LEAN_EXPORT lean_object* l_ReaderT_pure___at_Lean_Elab_Term_addTermInfo___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_throwErrorIfErrors(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520_(lean_object*); +LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522_(lean_object*); LEAN_EXPORT lean_object* l_Std_PersistentArray_mapM___at_Lean_Elab_Term_withoutModifyingElabMetaStateWithInfo___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Elab_Term_evalExpr___spec__13(lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_addAutoBoundImplicits(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -1338,13 +1338,13 @@ LEAN_EXPORT lean_object* l_Lean_setEnv___at_Lean_Elab_Term_evalExpr___spec__4(le LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___at_Lean_Elab_Term_evalExpr___spec__7(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_withoutModifyingElabMetaStateWithInfo___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_tryLiftAndCoe___closed__7; -static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__3; static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_elabUsingElabFns___closed__2; static lean_object* l_Lean_Elab_mkDeclName___at_Lean_Elab_Term_expandDeclId___spec__2___closed__3; uint8_t l_Lean_isStructure(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_List_filterAux___at_Lean_Elab_Term_resolveId_x3f___spec__2(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_addTermInfo___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Elab_Term_TermElabM_toIO(lean_object*); +static lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__3; LEAN_EXPORT lean_object* l_Lean_Elab_Term_applyAttributes___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_dropTermParens(lean_object*); static lean_object* l___private_Lean_Elab_Term_0__Lean_Elab_Term_mkSyntheticSorryFor___closed__1; @@ -48403,7 +48403,7 @@ return x_2; LEAN_EXPORT lean_object* l_Lean_Elab_Term_evalExpr___rarg___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { _start: { -lean_object* x_12; lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_dec(x_4); x_12 = lean_box(0); lean_inc(x_1); @@ -48411,53 +48411,58 @@ x_13 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_13, 0, x_1); lean_ctor_set(x_13, 1, x_12); lean_ctor_set(x_13, 2, x_2); -x_14 = lean_box(0); -x_15 = 0; -x_16 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_16, 0, x_13); -lean_ctor_set(x_16, 1, x_3); -lean_ctor_set(x_16, 2, x_14); -lean_ctor_set_uint8(x_16, sizeof(void*)*3, x_15); -x_17 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_17, 0, x_16); +lean_inc(x_1); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_1); +lean_ctor_set(x_14, 1, x_12); +x_15 = lean_box(0); +x_16 = 0; +x_17 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_17, 0, x_13); +lean_ctor_set(x_17, 1, x_3); +lean_ctor_set(x_17, 2, x_15); +lean_ctor_set(x_17, 3, x_14); +lean_ctor_set_uint8(x_17, sizeof(void*)*4, x_16); +x_18 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_18, 0, x_17); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_17); -x_18 = l_Lean_Elab_Term_ensureNoUnassignedMVars(x_17, x_5, x_6, x_7, x_8, x_9, x_10, x_11); -if (lean_obj_tag(x_18) == 0) +lean_inc(x_18); +x_19 = l_Lean_Elab_Term_ensureNoUnassignedMVars(x_18, x_5, x_6, x_7, x_8, x_9, x_10, x_11); +if (lean_obj_tag(x_19) == 0) { -lean_object* x_19; lean_object* x_20; -x_19 = lean_ctor_get(x_18, 1); -lean_inc(x_19); -lean_dec(x_18); +lean_object* x_20; lean_object* x_21; +x_20 = lean_ctor_get(x_19, 1); +lean_inc(x_20); +lean_dec(x_19); lean_inc(x_10); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_20 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_17, x_5, x_6, x_7, x_8, x_9, x_10, x_19); -if (lean_obj_tag(x_20) == 0) +x_21 = l_Lean_addAndCompile___at_Lean_Elab_Term_evalExpr___spec__1(x_18, x_5, x_6, x_7, x_8, x_9, x_10, x_20); +if (lean_obj_tag(x_21) == 0) { -lean_object* x_21; lean_object* x_22; -x_21 = lean_ctor_get(x_20, 1); -lean_inc(x_21); -lean_dec(x_20); -x_22 = l_Lean_evalConst___at_Lean_Elab_Term_evalExpr___spec__11___rarg(x_1, x_5, x_6, x_7, x_8, x_9, x_10, x_21); +lean_object* x_22; lean_object* x_23; +x_22 = lean_ctor_get(x_21, 1); +lean_inc(x_22); +lean_dec(x_21); +x_23 = l_Lean_evalConst___at_Lean_Elab_Term_evalExpr___spec__11___rarg(x_1, x_5, x_6, x_7, x_8, x_9, x_10, x_22); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -return x_22; +return x_23; } else { -uint8_t x_23; +uint8_t x_24; lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -48465,30 +48470,30 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_23 = !lean_is_exclusive(x_20); -if (x_23 == 0) +x_24 = !lean_is_exclusive(x_21); +if (x_24 == 0) { -return x_20; +return x_21; } else { -lean_object* x_24; lean_object* x_25; lean_object* x_26; -x_24 = lean_ctor_get(x_20, 0); -x_25 = lean_ctor_get(x_20, 1); +lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_25 = lean_ctor_get(x_21, 0); +x_26 = lean_ctor_get(x_21, 1); +lean_inc(x_26); lean_inc(x_25); -lean_inc(x_24); -lean_dec(x_20); -x_26 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_26, 0, x_24); -lean_ctor_set(x_26, 1, x_25); -return x_26; +lean_dec(x_21); +x_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; } } } else { -uint8_t x_27; -lean_dec(x_17); +uint8_t x_28; +lean_dec(x_18); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); @@ -48496,23 +48501,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_27 = !lean_is_exclusive(x_18); -if (x_27 == 0) +x_28 = !lean_is_exclusive(x_19); +if (x_28 == 0) { -return x_18; +return x_19; } else { -lean_object* x_28; lean_object* x_29; lean_object* x_30; -x_28 = lean_ctor_get(x_18, 0); -x_29 = lean_ctor_get(x_18, 1); +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_19, 0); +x_30 = lean_ctor_get(x_19, 1); +lean_inc(x_30); lean_inc(x_29); -lean_inc(x_28); -lean_dec(x_18); -x_30 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_30, 0, x_28); -lean_ctor_set(x_30, 1, x_29); -return x_30; +lean_dec(x_19); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; } } } @@ -51668,7 +51673,7 @@ x_3 = lean_alloc_closure((void*)(l_Lean_Elab_withoutModifyingStateWithInfoAndMes return x_3; } } -static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__1() { +static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -51678,7 +51683,7 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__2() { +static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__2() { _start: { lean_object* x_1; @@ -51686,17 +51691,17 @@ x_1 = lean_mk_string_from_bytes("debug", 5); return x_1; } } -static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__3() { +static lean_object* _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = l_Lean_Elab_Term_MVarErrorInfo_logError___closed__11; -x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__2; +x_2 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__2; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520_(lean_object* x_1) { +LEAN_EXPORT lean_object* l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522_(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; @@ -51708,7 +51713,7 @@ lean_object* x_4; lean_object* x_5; lean_object* x_6; x_4 = lean_ctor_get(x_3, 1); lean_inc(x_4); lean_dec(x_3); -x_5 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__1; +x_5 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__1; x_6 = l_Lean_registerTraceClass(x_5, x_4); if (lean_obj_tag(x_6) == 0) { @@ -51716,7 +51721,7 @@ lean_object* x_7; lean_object* x_8; lean_object* x_9; x_7 = lean_ctor_get(x_6, 1); lean_inc(x_7); lean_dec(x_6); -x_8 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__3; +x_8 = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__3; x_9 = l_Lean_registerTraceClass(x_8, x_7); return x_9; } @@ -52724,13 +52729,13 @@ l_Lean_Elab_Term_expandDeclId___closed__1 = _init_l_Lean_Elab_Term_expandDeclId_ lean_mark_persistent(l_Lean_Elab_Term_expandDeclId___closed__1); l_Lean_Elab_Term_expandDeclId___closed__2 = _init_l_Lean_Elab_Term_expandDeclId___closed__2(); lean_mark_persistent(l_Lean_Elab_Term_expandDeclId___closed__2); -l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__1(); -lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__1); -l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__2(); -lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__2); -l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__3(); -lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520____closed__3); -res = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15520_(lean_io_mk_world()); +l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__1 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__1(); +lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__1); +l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__2 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__2(); +lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__2); +l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__3 = _init_l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__3(); +lean_mark_persistent(l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522____closed__3); +res = l_Lean_Elab_initFn____x40_Lean_Elab_Term___hyg_15522_(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); return lean_io_result_mk_ok(lean_box(0)); diff --git a/stage0/stdlib/Lean/Meta/Closure.c b/stage0/stdlib/Lean/Meta/Closure.c index c7b57e0681..fbdc121f63 100644 --- a/stage0/stdlib/Lean/Meta/Closure.c +++ b/stage0/stdlib/Lean/Meta/Closure.c @@ -13754,7 +13754,7 @@ lean_inc(x_6); x_11 = l_Lean_Meta_Closure_mkValueTypeClosure(x_2, x_3, x_4, x_6, x_7, x_8, x_9, x_10); if (lean_obj_tag(x_11) == 0) { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint32_t x_24; uint32_t x_25; uint32_t x_26; lean_object* x_27; uint8_t x_28; +lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint32_t x_24; uint32_t x_25; uint32_t x_26; lean_object* x_27; uint8_t x_28; lean_object* x_29; lean_object* x_30; x_12 = lean_ctor_get(x_11, 0); lean_inc(x_12); x_13 = lean_ctor_get(x_11, 1); @@ -13793,402 +13793,410 @@ x_27 = lean_alloc_ctor(2, 0, 4); lean_ctor_set_uint32(x_27, 0, x_26); lean_inc(x_17); x_28 = l_Lean_Environment_hasUnsafe(x_17, x_20); +x_29 = lean_box(0); +lean_inc(x_1); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_1); +lean_ctor_set(x_30, 1, x_29); if (x_28 == 0) { -uint8_t x_29; +uint8_t x_31; lean_inc(x_22); -x_29 = l_Lean_Environment_hasUnsafe(x_17, x_22); -if (x_29 == 0) +x_31 = l_Lean_Environment_hasUnsafe(x_17, x_22); +if (x_31 == 0) { -uint8_t x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_21); -lean_ctor_set(x_31, 1, x_22); -lean_ctor_set(x_31, 2, x_27); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); +uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_32 = 1; +x_33 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_33, 0, x_21); +lean_ctor_set(x_33, 1, x_22); +lean_ctor_set(x_33, 2, x_27); +lean_ctor_set(x_33, 3, x_30); +lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32); +x_34 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_34, 0, x_33); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); -lean_inc(x_32); -x_33 = l_Lean_addDecl___at_Lean_Meta_mkAuxDefinition___spec__1(x_32, x_6, x_7, x_8, x_9, x_16); -if (lean_obj_tag(x_33) == 0) +lean_inc(x_34); +x_35 = l_Lean_addDecl___at_Lean_Meta_mkAuxDefinition___spec__1(x_34, x_6, x_7, x_8, x_9, x_16); +if (lean_obj_tag(x_35) == 0) { if (x_5 == 0) { -lean_object* x_34; lean_object* x_35; lean_object* x_36; -lean_dec(x_32); -x_34 = lean_ctor_get(x_33, 1); -lean_inc(x_34); -lean_dec(x_33); -x_35 = lean_box(0); -x_36 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_35, x_6, x_7, x_8, x_9, x_34); +lean_object* x_36; lean_object* x_37; lean_object* x_38; +lean_dec(x_34); +x_36 = lean_ctor_get(x_35, 1); +lean_inc(x_36); +lean_dec(x_35); +x_37 = lean_box(0); +x_38 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_37, x_6, x_7, x_8, x_9, x_36); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -return x_36; -} -else -{ -lean_object* x_37; lean_object* x_38; -x_37 = lean_ctor_get(x_33, 1); -lean_inc(x_37); -lean_dec(x_33); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_6); -x_38 = l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__5(x_32, x_6, x_7, x_8, x_9, x_37); -if (lean_obj_tag(x_38) == 0) -{ -lean_object* x_39; lean_object* x_40; lean_object* x_41; -x_39 = lean_ctor_get(x_38, 0); -lean_inc(x_39); -x_40 = lean_ctor_get(x_38, 1); -lean_inc(x_40); -lean_dec(x_38); -x_41 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_39, x_6, x_7, x_8, x_9, x_40); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_39); -return x_41; -} -else -{ -uint8_t x_42; -lean_dec(x_12); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_1); -x_42 = !lean_is_exclusive(x_38); -if (x_42 == 0) -{ return x_38; } else { -lean_object* x_43; lean_object* x_44; lean_object* x_45; -x_43 = lean_ctor_get(x_38, 0); -x_44 = lean_ctor_get(x_38, 1); -lean_inc(x_44); -lean_inc(x_43); -lean_dec(x_38); -x_45 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_45, 0, x_43); -lean_ctor_set(x_45, 1, x_44); -return x_45; -} -} -} +lean_object* x_39; lean_object* x_40; +x_39 = lean_ctor_get(x_35, 1); +lean_inc(x_39); +lean_dec(x_35); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_40 = l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__5(x_34, x_6, x_7, x_8, x_9, x_39); +if (lean_obj_tag(x_40) == 0) +{ +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_40, 0); +lean_inc(x_41); +x_42 = lean_ctor_get(x_40, 1); +lean_inc(x_42); +lean_dec(x_40); +x_43 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_41, x_6, x_7, x_8, x_9, x_42); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_41); +return x_43; } else { -uint8_t x_46; -lean_dec(x_32); +uint8_t x_44; lean_dec(x_12); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_1); -x_46 = !lean_is_exclusive(x_33); -if (x_46 == 0) +x_44 = !lean_is_exclusive(x_40); +if (x_44 == 0) { -return x_33; +return x_40; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -x_47 = lean_ctor_get(x_33, 0); -x_48 = lean_ctor_get(x_33, 1); -lean_inc(x_48); -lean_inc(x_47); -lean_dec(x_33); -x_49 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_49, 0, x_47); -lean_ctor_set(x_49, 1, x_48); -return x_49; +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_40, 0); +x_46 = lean_ctor_get(x_40, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_40); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; +} } } } else { -uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; -x_50 = 0; -x_51 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_51, 0, x_21); -lean_ctor_set(x_51, 1, x_22); -lean_ctor_set(x_51, 2, x_27); -lean_ctor_set_uint8(x_51, sizeof(void*)*3, x_50); -x_52 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_52, 0, x_51); +uint8_t x_48; +lean_dec(x_34); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_48 = !lean_is_exclusive(x_35); +if (x_48 == 0) +{ +return x_35; +} +else +{ +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_35, 0); +x_50 = lean_ctor_get(x_35, 1); +lean_inc(x_50); +lean_inc(x_49); +lean_dec(x_35); +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; +} +} +} +else +{ +uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = 0; +x_53 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_53, 0, x_21); +lean_ctor_set(x_53, 1, x_22); +lean_ctor_set(x_53, 2, x_27); +lean_ctor_set(x_53, 3, x_30); +lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_52); +x_54 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_54, 0, x_53); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); -lean_inc(x_52); -x_53 = l_Lean_addDecl___at_Lean_Meta_mkAuxDefinition___spec__1(x_52, x_6, x_7, x_8, x_9, x_16); -if (lean_obj_tag(x_53) == 0) +lean_inc(x_54); +x_55 = l_Lean_addDecl___at_Lean_Meta_mkAuxDefinition___spec__1(x_54, x_6, x_7, x_8, x_9, x_16); +if (lean_obj_tag(x_55) == 0) { if (x_5 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; -lean_dec(x_52); -x_54 = lean_ctor_get(x_53, 1); -lean_inc(x_54); -lean_dec(x_53); -x_55 = lean_box(0); -x_56 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_55, x_6, x_7, x_8, x_9, x_54); +lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_dec(x_54); +x_56 = lean_ctor_get(x_55, 1); +lean_inc(x_56); +lean_dec(x_55); +x_57 = lean_box(0); +x_58 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_57, x_6, x_7, x_8, x_9, x_56); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -return x_56; -} -else -{ -lean_object* x_57; lean_object* x_58; -x_57 = lean_ctor_get(x_53, 1); -lean_inc(x_57); -lean_dec(x_53); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_6); -x_58 = l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__5(x_52, x_6, x_7, x_8, x_9, x_57); -if (lean_obj_tag(x_58) == 0) -{ -lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); -x_60 = lean_ctor_get(x_58, 1); -lean_inc(x_60); -lean_dec(x_58); -x_61 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_59, x_6, x_7, x_8, x_9, x_60); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_59); -return x_61; -} -else -{ -uint8_t x_62; -lean_dec(x_12); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_1); -x_62 = !lean_is_exclusive(x_58); -if (x_62 == 0) -{ return x_58; } else { -lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_63 = lean_ctor_get(x_58, 0); -x_64 = lean_ctor_get(x_58, 1); -lean_inc(x_64); -lean_inc(x_63); -lean_dec(x_58); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_63); -lean_ctor_set(x_65, 1, x_64); -return x_65; -} -} -} +lean_object* x_59; lean_object* x_60; +x_59 = lean_ctor_get(x_55, 1); +lean_inc(x_59); +lean_dec(x_55); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_60 = l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__5(x_54, x_6, x_7, x_8, x_9, x_59); +if (lean_obj_tag(x_60) == 0) +{ +lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_60, 1); +lean_inc(x_62); +lean_dec(x_60); +x_63 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_61, x_6, x_7, x_8, x_9, x_62); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_61); +return x_63; } else { -uint8_t x_66; -lean_dec(x_52); +uint8_t x_64; lean_dec(x_12); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_1); -x_66 = !lean_is_exclusive(x_53); -if (x_66 == 0) +x_64 = !lean_is_exclusive(x_60); +if (x_64 == 0) { -return x_53; +return x_60; } else { -lean_object* x_67; lean_object* x_68; lean_object* x_69; -x_67 = lean_ctor_get(x_53, 0); -x_68 = lean_ctor_get(x_53, 1); -lean_inc(x_68); -lean_inc(x_67); -lean_dec(x_53); -x_69 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_69, 0, x_67); -lean_ctor_set(x_69, 1, x_68); -return x_69; +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_ctor_get(x_60, 0); +x_66 = lean_ctor_get(x_60, 1); +lean_inc(x_66); +lean_inc(x_65); +lean_dec(x_60); +x_67 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_67, 0, x_65); +lean_ctor_set(x_67, 1, x_66); +return x_67; } } } } else { -uint8_t x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +uint8_t x_68; +lean_dec(x_54); +lean_dec(x_12); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_68 = !lean_is_exclusive(x_55); +if (x_68 == 0) +{ +return x_55; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_55, 0); +x_70 = lean_ctor_get(x_55, 1); +lean_inc(x_70); +lean_inc(x_69); +lean_dec(x_55); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set(x_71, 1, x_70); +return x_71; +} +} +} +} +else +{ +uint8_t x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_dec(x_17); -x_70 = 0; -x_71 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_71, 0, x_21); -lean_ctor_set(x_71, 1, x_22); -lean_ctor_set(x_71, 2, x_27); -lean_ctor_set_uint8(x_71, sizeof(void*)*3, x_70); -x_72 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_72, 0, x_71); +x_72 = 0; +x_73 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_73, 0, x_21); +lean_ctor_set(x_73, 1, x_22); +lean_ctor_set(x_73, 2, x_27); +lean_ctor_set(x_73, 3, x_30); +lean_ctor_set_uint8(x_73, sizeof(void*)*4, x_72); +x_74 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_74, 0, x_73); lean_inc(x_9); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); -lean_inc(x_72); -x_73 = l_Lean_addDecl___at_Lean_Meta_mkAuxDefinition___spec__1(x_72, x_6, x_7, x_8, x_9, x_16); -if (lean_obj_tag(x_73) == 0) +lean_inc(x_74); +x_75 = l_Lean_addDecl___at_Lean_Meta_mkAuxDefinition___spec__1(x_74, x_6, x_7, x_8, x_9, x_16); +if (lean_obj_tag(x_75) == 0) { if (x_5 == 0) { -lean_object* x_74; lean_object* x_75; lean_object* x_76; -lean_dec(x_72); -x_74 = lean_ctor_get(x_73, 1); -lean_inc(x_74); -lean_dec(x_73); -x_75 = lean_box(0); -x_76 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_75, x_6, x_7, x_8, x_9, x_74); +lean_object* x_76; lean_object* x_77; lean_object* x_78; +lean_dec(x_74); +x_76 = lean_ctor_get(x_75, 1); +lean_inc(x_76); +lean_dec(x_75); +x_77 = lean_box(0); +x_78 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_77, x_6, x_7, x_8, x_9, x_76); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -return x_76; -} -else -{ -lean_object* x_77; lean_object* x_78; -x_77 = lean_ctor_get(x_73, 1); -lean_inc(x_77); -lean_dec(x_73); -lean_inc(x_9); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_6); -x_78 = l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__5(x_72, x_6, x_7, x_8, x_9, x_77); -if (lean_obj_tag(x_78) == 0) -{ -lean_object* x_79; lean_object* x_80; lean_object* x_81; -x_79 = lean_ctor_get(x_78, 0); -lean_inc(x_79); -x_80 = lean_ctor_get(x_78, 1); -lean_inc(x_80); -lean_dec(x_78); -x_81 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_79, x_6, x_7, x_8, x_9, x_80); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_79); -return x_81; -} -else -{ -uint8_t x_82; -lean_dec(x_12); -lean_dec(x_9); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_1); -x_82 = !lean_is_exclusive(x_78); -if (x_82 == 0) -{ return x_78; } else { -lean_object* x_83; lean_object* x_84; lean_object* x_85; -x_83 = lean_ctor_get(x_78, 0); -x_84 = lean_ctor_get(x_78, 1); -lean_inc(x_84); -lean_inc(x_83); -lean_dec(x_78); -x_85 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_85, 0, x_83); -lean_ctor_set(x_85, 1, x_84); -return x_85; -} -} -} +lean_object* x_79; lean_object* x_80; +x_79 = lean_ctor_get(x_75, 1); +lean_inc(x_79); +lean_dec(x_75); +lean_inc(x_9); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +x_80 = l_Lean_compileDecl___at_Lean_Meta_mkAuxDefinition___spec__5(x_74, x_6, x_7, x_8, x_9, x_79); +if (lean_obj_tag(x_80) == 0) +{ +lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_81 = lean_ctor_get(x_80, 0); +lean_inc(x_81); +x_82 = lean_ctor_get(x_80, 1); +lean_inc(x_82); +lean_dec(x_80); +x_83 = l_Lean_Meta_mkAuxDefinition___lambda__1(x_12, x_1, x_81, x_6, x_7, x_8, x_9, x_82); +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_81); +return x_83; } else { -uint8_t x_86; -lean_dec(x_72); +uint8_t x_84; lean_dec(x_12); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_1); -x_86 = !lean_is_exclusive(x_73); -if (x_86 == 0) +x_84 = !lean_is_exclusive(x_80); +if (x_84 == 0) { -return x_73; +return x_80; } else { -lean_object* x_87; lean_object* x_88; lean_object* x_89; -x_87 = lean_ctor_get(x_73, 0); -x_88 = lean_ctor_get(x_73, 1); -lean_inc(x_88); -lean_inc(x_87); -lean_dec(x_73); -x_89 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_89, 0, x_87); -lean_ctor_set(x_89, 1, x_88); -return x_89; +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_80, 0); +x_86 = lean_ctor_get(x_80, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_80); +x_87 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set(x_87, 1, x_86); +return x_87; } } } } else { -uint8_t x_90; +uint8_t x_88; +lean_dec(x_74); +lean_dec(x_12); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_1); -x_90 = !lean_is_exclusive(x_11); -if (x_90 == 0) +x_88 = !lean_is_exclusive(x_75); +if (x_88 == 0) +{ +return x_75; +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = lean_ctor_get(x_75, 0); +x_90 = lean_ctor_get(x_75, 1); +lean_inc(x_90); +lean_inc(x_89); +lean_dec(x_75); +x_91 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_91, 0, x_89); +lean_ctor_set(x_91, 1, x_90); +return x_91; +} +} +} +} +else +{ +uint8_t x_92; +lean_dec(x_9); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_1); +x_92 = !lean_is_exclusive(x_11); +if (x_92 == 0) { return x_11; } else { -lean_object* x_91; lean_object* x_92; lean_object* x_93; -x_91 = lean_ctor_get(x_11, 0); -x_92 = lean_ctor_get(x_11, 1); -lean_inc(x_92); -lean_inc(x_91); +lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_93 = lean_ctor_get(x_11, 0); +x_94 = lean_ctor_get(x_11, 1); +lean_inc(x_94); +lean_inc(x_93); lean_dec(x_11); -x_93 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_93, 0, x_91); -lean_ctor_set(x_93, 1, x_92); -return x_93; +x_95 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_95, 0, x_93); +lean_ctor_set(x_95, 1, x_94); +return x_95; } } } diff --git a/stage0/stdlib/Lean/Meta/Constructions.c b/stage0/stdlib/Lean/Meta/Constructions.c index 380c077ba6..76bcc6d598 100644 --- a/stage0/stdlib/Lean/Meta/Constructions.c +++ b/stage0/stdlib/Lean/Meta/Constructions.c @@ -15,7 +15,7 @@ extern "C" { #endif uint8_t l_Lean_isRecCore(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__10(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_mk_brec_on(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_mkCasesOn(lean_object*); LEAN_EXPORT uint8_t l_List_foldlM___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__11___lambda__1(lean_object*, lean_object*); @@ -45,7 +45,7 @@ LEAN_EXPORT lean_object* l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnu lean_object* lean_st_ref_get(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Declaration_foldExprM___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__10___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__1; -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_mkNoConfusionEnum_mkToCtorIdx___closed__1; LEAN_EXPORT lean_object* l_Lean_mkNoConfusionCore___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); @@ -59,7 +59,7 @@ LEAN_EXPORT lean_object* l___private_Lean_Meta_Constructions_0__Lean_adaptFn___r LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_mkCasesOn___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l___private_Lean_Message_0__Lean_beqMessageSeverity____x40_Lean_Message___hyg_101_(uint8_t, uint8_t); -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkAppOptM(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_mkBelow___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_nat_add(lean_object*, lean_object*); @@ -139,8 +139,8 @@ LEAN_EXPORT lean_object* l_Lean_mkRecOn___rarg___lambda__1(lean_object*, lean_ob LEAN_EXPORT lean_object* l_Lean_addDecl___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__4___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_List_foldlM___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__13(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_List_foldlM___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__13___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2___closed__1; LEAN_EXPORT lean_object* l_Lean_mkCasesOnImp___boxed(lean_object*, lean_object*); static lean_object* l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; @@ -185,10 +185,10 @@ static lean_object* l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkT static lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___closed__2; lean_object* l_Lean_Syntax_getTailPos_x3f(lean_object*, uint8_t); extern lean_object* l_Lean_Expr_instBEqExpr; -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Constructions_0__Lean_adaptFn___rarg___lambda__1(lean_object*, lean_object*); static lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2___closed__2; -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__9; lean_object* l_List_lengthTRAux___rarg(lean_object*, lean_object*); static lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2___closed__1; @@ -227,7 +227,7 @@ lean_object* lean_mk_binduction_on(lean_object*, lean_object*); static lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__1; extern lean_object* l_Lean_casesOnSuffix; lean_object* l_Lean_Meta_instInhabitedMetaM___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkApp3(lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_log___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__6(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_mkBelow___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -3453,139 +3453,146 @@ x_2 = lean_mk_empty_array_with_capacity(x_1); return x_2; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { _start: { -lean_object* x_14; lean_object* x_15; uint8_t x_16; uint8_t x_17; uint8_t x_18; lean_object* x_19; -x_14 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1___closed__1; -lean_inc(x_8); -x_15 = lean_array_push(x_14, x_8); -x_16 = 0; -x_17 = 1; +lean_object* x_15; lean_object* x_16; uint8_t x_17; uint8_t x_18; uint8_t x_19; lean_object* x_20; +x_15 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1___closed__1; +lean_inc(x_9); +x_16 = lean_array_push(x_15, x_9); +x_17 = 0; x_18 = 1; -lean_inc(x_15); -x_19 = l_Lean_Meta_mkLambdaFVars(x_15, x_1, x_16, x_17, x_18, x_9, x_10, x_11, x_12, x_13); -if (lean_obj_tag(x_19) == 0) +x_19 = 1; +lean_inc(x_16); +x_20 = l_Lean_Meta_mkLambdaFVars(x_16, x_1, x_17, x_18, x_19, x_10, x_11, x_12, x_13, x_14); +if (lean_obj_tag(x_20) == 0) { -lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; -x_20 = lean_ctor_get(x_19, 0); -lean_inc(x_20); -x_21 = lean_ctor_get(x_19, 1); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; +x_21 = lean_ctor_get(x_20, 0); lean_inc(x_21); -lean_dec(x_19); -x_22 = l_Lean_casesOnSuffix; -x_23 = lean_name_mk_string(x_2, x_22); -x_24 = l_Lean_levelOne; -x_25 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_25, 0, x_24); -lean_ctor_set(x_25, 1, x_3); -x_26 = l_Lean_mkConst(x_23, x_25); -x_27 = l_Lean_mkAppB(x_26, x_20, x_8); -x_28 = l_Lean_mkAppN(x_27, x_4); -x_29 = l_Lean_Meta_mkLambdaFVars(x_15, x_28, x_16, x_17, x_18, x_9, x_10, x_11, x_12, x_21); -if (lean_obj_tag(x_29) == 0) +x_22 = lean_ctor_get(x_20, 1); +lean_inc(x_22); +lean_dec(x_20); +x_23 = l_Lean_casesOnSuffix; +x_24 = lean_name_mk_string(x_2, x_23); +x_25 = l_Lean_levelOne; +x_26 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_3); +x_27 = l_Lean_mkConst(x_24, x_26); +x_28 = l_Lean_mkAppB(x_27, x_21, x_9); +x_29 = l_Lean_mkAppN(x_28, x_4); +x_30 = l_Lean_Meta_mkLambdaFVars(x_16, x_29, x_17, x_18, x_19, x_10, x_11, x_12, x_13, x_22); +if (lean_obj_tag(x_30) == 0) { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_30 = lean_ctor_get(x_29, 0); -lean_inc(x_30); -x_31 = lean_ctor_get(x_29, 1); +lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_31 = lean_ctor_get(x_30, 0); lean_inc(x_31); -lean_dec(x_29); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); lean_inc(x_5); -x_32 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_32, 0, x_5); -lean_ctor_set(x_32, 1, x_6); -lean_ctor_set(x_32, 2, x_7); -x_33 = lean_box(1); -x_34 = 1; -x_35 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_35, 0, x_32); -lean_ctor_set(x_35, 1, x_30); -lean_ctor_set(x_35, 2, x_33); -lean_ctor_set_uint8(x_35, sizeof(void*)*3, x_34); -x_36 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_36, 0, x_35); +x_33 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_33, 0, x_5); +lean_ctor_set(x_33, 1, x_6); +lean_ctor_set(x_33, 2, x_7); +lean_inc(x_5); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_5); +lean_ctor_set(x_34, 1, x_8); +x_35 = lean_box(1); +x_36 = 1; +x_37 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_37, 0, x_33); +lean_ctor_set(x_37, 1, x_31); +lean_ctor_set(x_37, 2, x_35); +lean_ctor_set(x_37, 3, x_34); +lean_ctor_set_uint8(x_37, sizeof(void*)*4, x_36); +x_38 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_38, 0, x_37); +lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); lean_inc(x_10); -lean_inc(x_9); -x_37 = l_Lean_addAndCompile___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__3(x_36, x_9, x_10, x_11, x_12, x_31); -if (lean_obj_tag(x_37) == 0) +x_39 = l_Lean_addAndCompile___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__3(x_38, x_10, x_11, x_12, x_13, x_32); +if (lean_obj_tag(x_39) == 0) { -lean_object* x_38; uint8_t x_39; lean_object* x_40; -x_38 = lean_ctor_get(x_37, 1); -lean_inc(x_38); -lean_dec(x_37); -x_39 = 0; -x_40 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_5, x_39, x_9, x_10, x_11, x_12, x_38); +lean_object* x_40; uint8_t x_41; lean_object* x_42; +x_40 = lean_ctor_get(x_39, 1); +lean_inc(x_40); +lean_dec(x_39); +x_41 = 0; +x_42 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_5, x_41, x_10, x_11, x_12, x_13, x_40); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); -return x_40; +return x_42; } else { -uint8_t x_41; +uint8_t x_43; +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); lean_dec(x_5); -x_41 = !lean_is_exclusive(x_37); -if (x_41 == 0) +x_43 = !lean_is_exclusive(x_39); +if (x_43 == 0) { -return x_37; +return x_39; } else { -lean_object* x_42; lean_object* x_43; lean_object* x_44; -x_42 = lean_ctor_get(x_37, 0); -x_43 = lean_ctor_get(x_37, 1); -lean_inc(x_43); -lean_inc(x_42); -lean_dec(x_37); -x_44 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_44, 0, x_42); -lean_ctor_set(x_44, 1, x_43); -return x_44; +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_39, 0); +x_45 = lean_ctor_get(x_39, 1); +lean_inc(x_45); +lean_inc(x_44); +lean_dec(x_39); +x_46 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_46, 0, x_44); +lean_ctor_set(x_46, 1, x_45); +return x_46; } } } else { -uint8_t x_45; +uint8_t x_47; +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); +lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_45 = !lean_is_exclusive(x_29); -if (x_45 == 0) +x_47 = !lean_is_exclusive(x_30); +if (x_47 == 0) { -return x_29; +return x_30; } else { -lean_object* x_46; lean_object* x_47; lean_object* x_48; -x_46 = lean_ctor_get(x_29, 0); -x_47 = lean_ctor_get(x_29, 1); -lean_inc(x_47); -lean_inc(x_46); -lean_dec(x_29); -x_48 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_48, 0, x_46); -lean_ctor_set(x_48, 1, x_47); -return x_48; +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_30, 0); +x_49 = lean_ctor_get(x_30, 1); +lean_inc(x_49); +lean_inc(x_48); +lean_dec(x_30); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_48); +lean_ctor_set(x_50, 1, x_49); +return x_50; } } } else { -uint8_t x_49; -lean_dec(x_15); +uint8_t x_51; +lean_dec(x_16); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -3597,23 +3604,23 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_49 = !lean_is_exclusive(x_19); -if (x_49 == 0) +x_51 = !lean_is_exclusive(x_20); +if (x_51 == 0) { -return x_19; +return x_20; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_19, 0); -x_51 = lean_ctor_get(x_19, 1); -lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_19); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_20, 0); +x_53 = lean_ctor_get(x_20, 1); +lean_inc(x_53); +lean_inc(x_52); +lean_dec(x_20); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +return x_54; } } } @@ -3776,7 +3783,7 @@ lean_inc(x_28); x_29 = lean_ctor_get(x_27, 1); lean_inc(x_29); lean_dec(x_27); -x_30 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1), 13, 7); +x_30 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkToCtorIdx___lambda__1), 14, 8); lean_closure_set(x_30, 0, x_21); lean_closure_set(x_30, 1, x_1); lean_closure_set(x_30, 2, x_14); @@ -3784,6 +3791,7 @@ lean_closure_set(x_30, 3, x_28); lean_closure_set(x_30, 4, x_19); lean_closure_set(x_30, 5, x_12); lean_closure_set(x_30, 6, x_23); +lean_closure_set(x_30, 7, x_13); x_31 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___closed__11; x_32 = 0; x_33 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_31, x_32, x_20, x_30, x_2, x_3, x_4, x_5, x_29); @@ -3996,191 +4004,199 @@ x_1 = lean_mk_string_from_bytes("noConfusionType", 15); return x_1; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { _start: { -lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; uint8_t x_18; uint8_t x_19; uint8_t x_20; lean_object* x_21; -x_14 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__1; +lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; uint8_t x_20; uint8_t x_21; lean_object* x_22; +x_15 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__1; lean_inc(x_1); -x_15 = lean_array_push(x_14, x_1); +x_16 = lean_array_push(x_15, x_1); lean_inc(x_2); -x_16 = lean_array_push(x_15, x_2); -lean_inc(x_8); -x_17 = lean_array_push(x_16, x_8); -x_18 = 0; -x_19 = 1; +x_17 = lean_array_push(x_16, x_2); +lean_inc(x_9); +x_18 = lean_array_push(x_17, x_9); +x_19 = 0; x_20 = 1; -lean_inc(x_17); -x_21 = l_Lean_Meta_mkForallFVars(x_17, x_3, x_18, x_19, x_20, x_9, x_10, x_11, x_12, x_13); -if (lean_obj_tag(x_21) == 0) +x_21 = 1; +lean_inc(x_18); +x_22 = l_Lean_Meta_mkForallFVars(x_18, x_3, x_19, x_20, x_21, x_10, x_11, x_12, x_13, x_14); +if (lean_obj_tag(x_22) == 0) { -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; -x_22 = lean_ctor_get(x_21, 0); -lean_inc(x_22); -x_23 = lean_ctor_get(x_21, 1); +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_23 = lean_ctor_get(x_22, 0); lean_inc(x_23); -lean_dec(x_21); -x_24 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__4; -x_25 = lean_array_push(x_24, x_4); -x_26 = lean_array_push(x_25, x_1); -x_27 = lean_array_push(x_26, x_2); -x_28 = lean_array_push(x_27, x_8); -x_29 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__3; +x_24 = lean_ctor_get(x_22, 1); +lean_inc(x_24); +lean_dec(x_22); +x_25 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__4; +x_26 = lean_array_push(x_25, x_4); +x_27 = lean_array_push(x_26, x_1); +x_28 = lean_array_push(x_27, x_2); +x_29 = lean_array_push(x_28, x_9); +x_30 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__3; +lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); lean_inc(x_10); -lean_inc(x_9); -x_30 = l_Lean_Meta_mkAppM(x_29, x_28, x_9, x_10, x_11, x_12, x_23); -if (lean_obj_tag(x_30) == 0) +x_31 = l_Lean_Meta_mkAppM(x_30, x_29, x_10, x_11, x_12, x_13, x_24); +if (lean_obj_tag(x_31) == 0) { -lean_object* x_31; lean_object* x_32; lean_object* x_33; -x_31 = lean_ctor_get(x_30, 0); -lean_inc(x_31); -x_32 = lean_ctor_get(x_30, 1); +lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_32 = lean_ctor_get(x_31, 0); lean_inc(x_32); -lean_dec(x_30); -x_33 = l_Lean_Meta_mkLambdaFVars(x_17, x_31, x_18, x_19, x_20, x_9, x_10, x_11, x_12, x_32); -if (lean_obj_tag(x_33) == 0) +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +lean_dec(x_31); +x_34 = l_Lean_Meta_mkLambdaFVars(x_18, x_32, x_19, x_20, x_21, x_10, x_11, x_12, x_13, x_33); +if (lean_obj_tag(x_34) == 0) { -lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__5; -x_37 = lean_name_mk_string(x_5, x_36); -x_38 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_38, 0, x_6); -lean_ctor_set(x_38, 1, x_7); -lean_inc(x_37); -x_39 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_39, 0, x_37); -lean_ctor_set(x_39, 1, x_38); -lean_ctor_set(x_39, 2, x_22); -x_40 = lean_box(1); -x_41 = 1; -x_42 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_42, 0, x_39); -lean_ctor_set(x_42, 1, x_34); -lean_ctor_set(x_42, 2, x_40); -lean_ctor_set_uint8(x_42, sizeof(void*)*3, x_41); -x_43 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_43, 0, x_42); +x_36 = lean_ctor_get(x_34, 1); +lean_inc(x_36); +lean_dec(x_34); +x_37 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__5; +x_38 = lean_name_mk_string(x_5, x_37); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_6); +lean_ctor_set(x_39, 1, x_7); +lean_inc(x_38); +x_40 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +lean_ctor_set(x_40, 2, x_23); +lean_inc(x_38); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_38); +lean_ctor_set(x_41, 1, x_8); +x_42 = lean_box(1); +x_43 = 1; +x_44 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_44, 0, x_40); +lean_ctor_set(x_44, 1, x_35); +lean_ctor_set(x_44, 2, x_42); +lean_ctor_set(x_44, 3, x_41); +lean_ctor_set_uint8(x_44, sizeof(void*)*4, x_43); +x_45 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_45, 0, x_44); +lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); lean_inc(x_10); -lean_inc(x_9); -x_44 = l_Lean_addAndCompile___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__3(x_43, x_9, x_10, x_11, x_12, x_35); -if (lean_obj_tag(x_44) == 0) +x_46 = l_Lean_addAndCompile___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__3(x_45, x_10, x_11, x_12, x_13, x_36); +if (lean_obj_tag(x_46) == 0) { -lean_object* x_45; uint8_t x_46; lean_object* x_47; -x_45 = lean_ctor_get(x_44, 1); -lean_inc(x_45); -lean_dec(x_44); -x_46 = 0; -x_47 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_37, x_46, x_9, x_10, x_11, x_12, x_45); +lean_object* x_47; uint8_t x_48; lean_object* x_49; +x_47 = lean_ctor_get(x_46, 1); +lean_inc(x_47); +lean_dec(x_46); +x_48 = 0; +x_49 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_38, x_48, x_10, x_11, x_12, x_13, x_47); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); -return x_47; +return x_49; } else { -uint8_t x_48; -lean_dec(x_37); +uint8_t x_50; +lean_dec(x_38); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); -x_48 = !lean_is_exclusive(x_44); -if (x_48 == 0) +x_50 = !lean_is_exclusive(x_46); +if (x_50 == 0) { -return x_44; +return x_46; } else { -lean_object* x_49; lean_object* x_50; lean_object* x_51; -x_49 = lean_ctor_get(x_44, 0); -x_50 = lean_ctor_get(x_44, 1); -lean_inc(x_50); -lean_inc(x_49); -lean_dec(x_44); -x_51 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_51, 0, x_49); -lean_ctor_set(x_51, 1, x_50); -return x_51; +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_46, 0); +x_52 = lean_ctor_get(x_46, 1); +lean_inc(x_52); +lean_inc(x_51); +lean_dec(x_46); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } } else { -uint8_t x_52; -lean_dec(x_22); +uint8_t x_54; +lean_dec(x_23); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); +lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_52 = !lean_is_exclusive(x_33); -if (x_52 == 0) +x_54 = !lean_is_exclusive(x_34); +if (x_54 == 0) { -return x_33; +return x_34; } else { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = lean_ctor_get(x_33, 0); -x_54 = lean_ctor_get(x_33, 1); -lean_inc(x_54); -lean_inc(x_53); -lean_dec(x_33); -x_55 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_55, 0, x_53); -lean_ctor_set(x_55, 1, x_54); -return x_55; +lean_object* x_55; lean_object* x_56; lean_object* x_57; +x_55 = lean_ctor_get(x_34, 0); +x_56 = lean_ctor_get(x_34, 1); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_34); +x_57 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_57, 0, x_55); +lean_ctor_set(x_57, 1, x_56); +return x_57; } } } else { -uint8_t x_56; -lean_dec(x_22); -lean_dec(x_17); +uint8_t x_58; +lean_dec(x_23); +lean_dec(x_18); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); +lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_56 = !lean_is_exclusive(x_30); -if (x_56 == 0) +x_58 = !lean_is_exclusive(x_31); +if (x_58 == 0) { -return x_30; +return x_31; } else { -lean_object* x_57; lean_object* x_58; lean_object* x_59; -x_57 = lean_ctor_get(x_30, 0); -x_58 = lean_ctor_get(x_30, 1); -lean_inc(x_58); -lean_inc(x_57); -lean_dec(x_30); -x_59 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_59, 0, x_57); -lean_ctor_set(x_59, 1, x_58); -return x_59; +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_31, 0); +x_60 = lean_ctor_get(x_31, 1); +lean_inc(x_60); +lean_inc(x_59); +lean_dec(x_31); +x_61 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_60); +return x_61; } } } else { -uint8_t x_60; -lean_dec(x_17); +uint8_t x_62; +lean_dec(x_18); +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -4192,23 +4208,23 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); -x_60 = !lean_is_exclusive(x_21); -if (x_60 == 0) +x_62 = !lean_is_exclusive(x_22); +if (x_62 == 0) { -return x_21; +return x_22; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; -x_61 = lean_ctor_get(x_21, 0); -x_62 = lean_ctor_get(x_21, 1); -lean_inc(x_62); -lean_inc(x_61); -lean_dec(x_21); -x_63 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_63, 0, x_61); -lean_ctor_set(x_63, 1, x_62); -return x_63; +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_22, 0); +x_64 = lean_ctor_get(x_22, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_22); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; } } } @@ -4231,43 +4247,45 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +_start: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; +x_15 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1), 14, 8); +lean_closure_set(x_15, 0, x_1); +lean_closure_set(x_15, 1, x_9); +lean_closure_set(x_15, 2, x_2); +lean_closure_set(x_15, 3, x_3); +lean_closure_set(x_15, 4, x_4); +lean_closure_set(x_15, 5, x_5); +lean_closure_set(x_15, 6, x_6); +lean_closure_set(x_15, 7, x_7); +x_16 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2___closed__2; +x_17 = 0; +x_18 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_16, x_17, x_8, x_15, x_10, x_11, x_12, x_13, x_14); +return x_18; +} +} +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { _start: { lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; -x_14 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1), 13, 7); -lean_closure_set(x_14, 0, x_1); -lean_closure_set(x_14, 1, x_8); +lean_inc(x_7); +x_14 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2), 14, 8); +lean_closure_set(x_14, 0, x_8); +lean_closure_set(x_14, 1, x_1); lean_closure_set(x_14, 2, x_2); lean_closure_set(x_14, 3, x_3); lean_closure_set(x_14, 4, x_4); lean_closure_set(x_14, 5, x_5); lean_closure_set(x_14, 6, x_6); -x_15 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2___closed__2; +lean_closure_set(x_14, 7, x_7); +x_15 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___closed__11; x_16 = 0; x_17 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_15, x_16, x_7, x_14, x_9, x_10, x_11, x_12, x_13); return x_17; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { -_start: -{ -lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; -lean_inc(x_6); -x_13 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2), 13, 7); -lean_closure_set(x_13, 0, x_7); -lean_closure_set(x_13, 1, x_1); -lean_closure_set(x_13, 2, x_2); -lean_closure_set(x_13, 3, x_3); -lean_closure_set(x_13, 4, x_4); -lean_closure_set(x_13, 5, x_5); -lean_closure_set(x_13, 6, x_6); -x_14 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___closed__11; -x_15 = 0; -x_16 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_14, x_15, x_6, x_13, x_8, x_9, x_10, x_11, x_12); -return x_16; -} -} static lean_object* _init_l_Lean_mkNoConfusionEnum_mkNoConfusionType___closed__1() { _start: { @@ -4372,13 +4390,14 @@ lean_inc(x_1); x_23 = lean_name_mk_string(x_1, x_22); x_24 = l_Lean_mkConst(x_23, x_14); lean_inc(x_21); -x_25 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__3), 12, 6); +x_25 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__3), 13, 7); lean_closure_set(x_25, 0, x_21); lean_closure_set(x_25, 1, x_24); lean_closure_set(x_25, 2, x_1); lean_closure_set(x_25, 3, x_17); lean_closure_set(x_25, 4, x_12); -lean_closure_set(x_25, 5, x_19); +lean_closure_set(x_25, 5, x_13); +lean_closure_set(x_25, 6, x_19); x_26 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___closed__6; x_27 = 0; x_28 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_26, x_27, x_21, x_25, x_2, x_3, x_4, x_5, x_18); @@ -4499,401 +4518,409 @@ x_1 = l_Lean_noConfusionExt; return x_1; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { _start: { -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; uint8_t x_22; uint8_t x_23; lean_object* x_24; -x_15 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__4; +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; lean_object* x_25; +x_16 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__1___closed__4; lean_inc(x_1); -x_16 = lean_array_push(x_15, x_1); +x_17 = lean_array_push(x_16, x_1); lean_inc(x_2); -x_17 = lean_array_push(x_16, x_2); +x_18 = lean_array_push(x_17, x_2); lean_inc(x_3); -x_18 = lean_array_push(x_17, x_3); -lean_inc(x_9); -x_19 = lean_array_push(x_18, x_9); +x_19 = lean_array_push(x_18, x_3); +lean_inc(x_10); +x_20 = lean_array_push(x_19, x_10); lean_inc(x_3); lean_inc(x_2); lean_inc(x_1); -x_20 = l_Lean_mkApp3(x_4, x_1, x_2, x_3); -x_21 = 0; -x_22 = 1; +x_21 = l_Lean_mkApp3(x_4, x_1, x_2, x_3); +x_22 = 0; x_23 = 1; -lean_inc(x_19); -x_24 = l_Lean_Meta_mkForallFVars(x_19, x_20, x_21, x_22, x_23, x_10, x_11, x_12, x_13, x_14); -if (lean_obj_tag(x_24) == 0) +x_24 = 1; +lean_inc(x_20); +x_25 = l_Lean_Meta_mkForallFVars(x_20, x_21, x_22, x_23, x_24, x_11, x_12, x_13, x_14, x_15); +if (lean_obj_tag(x_25) == 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; 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; -x_25 = lean_ctor_get(x_24, 0); -lean_inc(x_25); -x_26 = lean_ctor_get(x_24, 1); +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; +x_26 = lean_ctor_get(x_25, 0); lean_inc(x_26); -lean_dec(x_24); -x_27 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_27, 0, x_5); +x_27 = lean_ctor_get(x_25, 1); +lean_inc(x_27); +lean_dec(x_25); x_28 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_28, 0, x_1); +lean_ctor_set(x_28, 0, x_5); x_29 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_29, 0, x_2); +lean_ctor_set(x_29, 0, x_1); x_30 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_30, 0, x_3); +lean_ctor_set(x_30, 0, x_2); x_31 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_31, 0, x_9); -x_32 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__6; -x_33 = lean_array_push(x_32, x_27); +lean_ctor_set(x_31, 0, x_3); +x_32 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_32, 0, x_10); +x_33 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__6; x_34 = lean_array_push(x_33, x_28); x_35 = lean_array_push(x_34, x_29); x_36 = lean_array_push(x_35, x_30); x_37 = lean_array_push(x_36, x_31); -x_38 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__2; +x_38 = lean_array_push(x_37, x_32); +x_39 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__2; +lean_inc(x_14); lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); -lean_inc(x_10); -x_39 = l_Lean_Meta_mkAppOptM(x_38, x_37, x_10, x_11, x_12, x_13, x_26); -if (lean_obj_tag(x_39) == 0) +x_40 = l_Lean_Meta_mkAppOptM(x_39, x_38, x_11, x_12, x_13, x_14, x_27); +if (lean_obj_tag(x_40) == 0) { -lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_40 = lean_ctor_get(x_39, 0); -lean_inc(x_40); -x_41 = lean_ctor_get(x_39, 1); +lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -lean_dec(x_39); -x_42 = l_Lean_Meta_mkLambdaFVars(x_19, x_40, x_21, x_22, x_23, x_10, x_11, x_12, x_13, x_41); -if (lean_obj_tag(x_42) == 0) +x_42 = lean_ctor_get(x_40, 1); +lean_inc(x_42); +lean_dec(x_40); +x_43 = l_Lean_Meta_mkLambdaFVars(x_20, x_41, x_22, x_23, x_24, x_11, x_12, x_13, x_14, x_42); +if (lean_obj_tag(x_43) == 0) { -lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; -x_43 = lean_ctor_get(x_42, 0); -lean_inc(x_43); -x_44 = lean_ctor_get(x_42, 1); +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_44 = lean_ctor_get(x_43, 0); lean_inc(x_44); -lean_dec(x_42); -x_45 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__7; -x_46 = lean_name_mk_string(x_6, x_45); -x_47 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_47, 0, x_7); -lean_ctor_set(x_47, 1, x_8); -lean_inc(x_46); -x_48 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_48, 0, x_46); -lean_ctor_set(x_48, 1, x_47); -lean_ctor_set(x_48, 2, x_25); -x_49 = lean_box(1); -x_50 = 1; -x_51 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_51, 0, x_48); -lean_ctor_set(x_51, 1, x_43); -lean_ctor_set(x_51, 2, x_49); -lean_ctor_set_uint8(x_51, sizeof(void*)*3, x_50); -x_52 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_52, 0, x_51); +x_45 = lean_ctor_get(x_43, 1); +lean_inc(x_45); +lean_dec(x_43); +x_46 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__7; +x_47 = lean_name_mk_string(x_6, x_46); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_7); +lean_ctor_set(x_48, 1, x_8); +lean_inc(x_47); +x_49 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_49, 0, x_47); +lean_ctor_set(x_49, 1, x_48); +lean_ctor_set(x_49, 2, x_26); +lean_inc(x_47); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_9); +x_51 = lean_box(1); +x_52 = 1; +x_53 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_53, 0, x_49); +lean_ctor_set(x_53, 1, x_44); +lean_ctor_set(x_53, 2, x_51); +lean_ctor_set(x_53, 3, x_50); +lean_ctor_set_uint8(x_53, sizeof(void*)*4, x_52); +x_54 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_54, 0, x_53); +lean_inc(x_14); lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); -lean_inc(x_10); -x_53 = l_Lean_addAndCompile___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__3(x_52, x_10, x_11, x_12, x_13, x_44); -if (lean_obj_tag(x_53) == 0) +x_55 = l_Lean_addAndCompile___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__3(x_54, x_11, x_12, x_13, x_14, x_45); +if (lean_obj_tag(x_55) == 0) { -lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; uint8_t x_61; -x_54 = lean_ctor_get(x_53, 1); -lean_inc(x_54); -lean_dec(x_53); -x_55 = 0; -lean_inc(x_46); -x_56 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_46, x_55, x_10, x_11, x_12, x_13, x_54); -lean_dec(x_12); -lean_dec(x_10); -x_57 = lean_ctor_get(x_56, 1); -lean_inc(x_57); -lean_dec(x_56); -x_58 = lean_st_ref_take(x_13, x_57); -x_59 = lean_ctor_get(x_58, 0); -lean_inc(x_59); -x_60 = lean_ctor_get(x_58, 1); -lean_inc(x_60); -lean_dec(x_58); -x_61 = !lean_is_exclusive(x_59); -if (x_61 == 0) -{ -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; uint8_t x_74; -x_62 = lean_ctor_get(x_59, 0); -x_63 = lean_ctor_get(x_59, 4); -lean_dec(x_63); -x_64 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__8; -x_65 = l_Lean_TagDeclarationExtension_tag(x_64, x_62, x_46); -x_66 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__4; -lean_ctor_set(x_59, 4, x_66); -lean_ctor_set(x_59, 0, x_65); -x_67 = lean_st_ref_set(x_13, x_59, x_60); -x_68 = lean_ctor_get(x_67, 1); -lean_inc(x_68); -lean_dec(x_67); -x_69 = lean_st_ref_get(x_13, x_68); +lean_object* x_56; uint8_t x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; +x_56 = lean_ctor_get(x_55, 1); +lean_inc(x_56); +lean_dec(x_55); +x_57 = 0; +lean_inc(x_47); +x_58 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14(x_47, x_57, x_11, x_12, x_13, x_14, x_56); lean_dec(x_13); +lean_dec(x_11); +x_59 = lean_ctor_get(x_58, 1); +lean_inc(x_59); +lean_dec(x_58); +x_60 = lean_st_ref_take(x_14, x_59); +x_61 = lean_ctor_get(x_60, 0); +lean_inc(x_61); +x_62 = lean_ctor_get(x_60, 1); +lean_inc(x_62); +lean_dec(x_60); +x_63 = !lean_is_exclusive(x_61); +if (x_63 == 0) +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; uint8_t x_76; +x_64 = lean_ctor_get(x_61, 0); +x_65 = lean_ctor_get(x_61, 4); +lean_dec(x_65); +x_66 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__8; +x_67 = l_Lean_TagDeclarationExtension_tag(x_66, x_64, x_47); +x_68 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__4; +lean_ctor_set(x_61, 4, x_68); +lean_ctor_set(x_61, 0, x_67); +x_69 = lean_st_ref_set(x_14, x_61, x_62); x_70 = lean_ctor_get(x_69, 1); lean_inc(x_70); lean_dec(x_69); -x_71 = lean_st_ref_take(x_11, x_70); -x_72 = lean_ctor_get(x_71, 0); +x_71 = lean_st_ref_get(x_14, x_70); +lean_dec(x_14); +x_72 = lean_ctor_get(x_71, 1); lean_inc(x_72); -x_73 = lean_ctor_get(x_71, 1); -lean_inc(x_73); lean_dec(x_71); -x_74 = !lean_is_exclusive(x_72); -if (x_74 == 0) +x_73 = lean_st_ref_take(x_12, x_72); +x_74 = lean_ctor_get(x_73, 0); +lean_inc(x_74); +x_75 = lean_ctor_get(x_73, 1); +lean_inc(x_75); +lean_dec(x_73); +x_76 = !lean_is_exclusive(x_74); +if (x_76 == 0) { -lean_object* x_75; lean_object* x_76; lean_object* x_77; uint8_t x_78; -x_75 = lean_ctor_get(x_72, 1); -lean_dec(x_75); -x_76 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; -lean_ctor_set(x_72, 1, x_76); -x_77 = lean_st_ref_set(x_11, x_72, x_73); -lean_dec(x_11); -x_78 = !lean_is_exclusive(x_77); -if (x_78 == 0) -{ -lean_object* x_79; lean_object* x_80; -x_79 = lean_ctor_get(x_77, 0); -lean_dec(x_79); -x_80 = lean_box(0); -lean_ctor_set(x_77, 0, x_80); -return x_77; -} -else -{ -lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_81 = lean_ctor_get(x_77, 1); -lean_inc(x_81); +lean_object* x_77; lean_object* x_78; lean_object* x_79; uint8_t x_80; +x_77 = lean_ctor_get(x_74, 1); lean_dec(x_77); +x_78 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; +lean_ctor_set(x_74, 1, x_78); +x_79 = lean_st_ref_set(x_12, x_74, x_75); +lean_dec(x_12); +x_80 = !lean_is_exclusive(x_79); +if (x_80 == 0) +{ +lean_object* x_81; lean_object* x_82; +x_81 = lean_ctor_get(x_79, 0); +lean_dec(x_81); x_82 = lean_box(0); -x_83 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_83, 0, x_82); -lean_ctor_set(x_83, 1, x_81); -return x_83; +lean_ctor_set(x_79, 0, x_82); +return x_79; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_79, 1); +lean_inc(x_83); +lean_dec(x_79); +x_84 = lean_box(0); +x_85 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_85, 0, x_84); +lean_ctor_set(x_85, 1, x_83); +return x_85; } } else { -lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; -x_84 = lean_ctor_get(x_72, 0); -x_85 = lean_ctor_get(x_72, 2); -x_86 = lean_ctor_get(x_72, 3); +lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; +x_86 = lean_ctor_get(x_74, 0); +x_87 = lean_ctor_get(x_74, 2); +x_88 = lean_ctor_get(x_74, 3); +lean_inc(x_88); +lean_inc(x_87); lean_inc(x_86); -lean_inc(x_85); -lean_inc(x_84); -lean_dec(x_72); -x_87 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; -x_88 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_88, 0, x_84); -lean_ctor_set(x_88, 1, x_87); -lean_ctor_set(x_88, 2, x_85); -lean_ctor_set(x_88, 3, x_86); -x_89 = lean_st_ref_set(x_11, x_88, x_73); -lean_dec(x_11); -x_90 = lean_ctor_get(x_89, 1); -lean_inc(x_90); -if (lean_is_exclusive(x_89)) { - lean_ctor_release(x_89, 0); - lean_ctor_release(x_89, 1); - x_91 = x_89; -} else { - lean_dec_ref(x_89); - x_91 = lean_box(0); -} -x_92 = lean_box(0); -if (lean_is_scalar(x_91)) { - x_93 = lean_alloc_ctor(0, 2, 0); -} else { +lean_dec(x_74); +x_89 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; +x_90 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_90, 0, x_86); +lean_ctor_set(x_90, 1, x_89); +lean_ctor_set(x_90, 2, x_87); +lean_ctor_set(x_90, 3, x_88); +x_91 = lean_st_ref_set(x_12, x_90, x_75); +lean_dec(x_12); +x_92 = lean_ctor_get(x_91, 1); +lean_inc(x_92); +if (lean_is_exclusive(x_91)) { + lean_ctor_release(x_91, 0); + lean_ctor_release(x_91, 1); x_93 = x_91; +} else { + lean_dec_ref(x_91); + x_93 = lean_box(0); } -lean_ctor_set(x_93, 0, x_92); -lean_ctor_set(x_93, 1, x_90); -return x_93; +x_94 = lean_box(0); +if (lean_is_scalar(x_93)) { + x_95 = lean_alloc_ctor(0, 2, 0); +} else { + x_95 = x_93; +} +lean_ctor_set(x_95, 0, x_94); +lean_ctor_set(x_95, 1, x_92); +return x_95; } } else { -lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; -x_94 = lean_ctor_get(x_59, 0); -x_95 = lean_ctor_get(x_59, 1); -x_96 = lean_ctor_get(x_59, 2); -x_97 = lean_ctor_get(x_59, 3); -x_98 = lean_ctor_get(x_59, 5); +lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; +x_96 = lean_ctor_get(x_61, 0); +x_97 = lean_ctor_get(x_61, 1); +x_98 = lean_ctor_get(x_61, 2); +x_99 = lean_ctor_get(x_61, 3); +x_100 = lean_ctor_get(x_61, 5); +lean_inc(x_100); +lean_inc(x_99); lean_inc(x_98); lean_inc(x_97); lean_inc(x_96); -lean_inc(x_95); -lean_inc(x_94); -lean_dec(x_59); -x_99 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__8; -x_100 = l_Lean_TagDeclarationExtension_tag(x_99, x_94, x_46); -x_101 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__4; -x_102 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_102, 0, x_100); -lean_ctor_set(x_102, 1, x_95); -lean_ctor_set(x_102, 2, x_96); -lean_ctor_set(x_102, 3, x_97); -lean_ctor_set(x_102, 4, x_101); -lean_ctor_set(x_102, 5, x_98); -x_103 = lean_st_ref_set(x_13, x_102, x_60); -x_104 = lean_ctor_get(x_103, 1); -lean_inc(x_104); -lean_dec(x_103); -x_105 = lean_st_ref_get(x_13, x_104); -lean_dec(x_13); +lean_dec(x_61); +x_101 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1___closed__8; +x_102 = l_Lean_TagDeclarationExtension_tag(x_101, x_96, x_47); +x_103 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__4; +x_104 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_104, 0, x_102); +lean_ctor_set(x_104, 1, x_97); +lean_ctor_set(x_104, 2, x_98); +lean_ctor_set(x_104, 3, x_99); +lean_ctor_set(x_104, 4, x_103); +lean_ctor_set(x_104, 5, x_100); +x_105 = lean_st_ref_set(x_14, x_104, x_62); x_106 = lean_ctor_get(x_105, 1); lean_inc(x_106); lean_dec(x_105); -x_107 = lean_st_ref_take(x_11, x_106); -x_108 = lean_ctor_get(x_107, 0); +x_107 = lean_st_ref_get(x_14, x_106); +lean_dec(x_14); +x_108 = lean_ctor_get(x_107, 1); lean_inc(x_108); -x_109 = lean_ctor_get(x_107, 1); -lean_inc(x_109); lean_dec(x_107); -x_110 = lean_ctor_get(x_108, 0); +x_109 = lean_st_ref_take(x_12, x_108); +x_110 = lean_ctor_get(x_109, 0); lean_inc(x_110); -x_111 = lean_ctor_get(x_108, 2); +x_111 = lean_ctor_get(x_109, 1); lean_inc(x_111); -x_112 = lean_ctor_get(x_108, 3); +lean_dec(x_109); +x_112 = lean_ctor_get(x_110, 0); lean_inc(x_112); -if (lean_is_exclusive(x_108)) { - lean_ctor_release(x_108, 0); - lean_ctor_release(x_108, 1); - lean_ctor_release(x_108, 2); - lean_ctor_release(x_108, 3); - x_113 = x_108; +x_113 = lean_ctor_get(x_110, 2); +lean_inc(x_113); +x_114 = lean_ctor_get(x_110, 3); +lean_inc(x_114); +if (lean_is_exclusive(x_110)) { + lean_ctor_release(x_110, 0); + lean_ctor_release(x_110, 1); + lean_ctor_release(x_110, 2); + lean_ctor_release(x_110, 3); + x_115 = x_110; } else { - lean_dec_ref(x_108); - x_113 = lean_box(0); + lean_dec_ref(x_110); + x_115 = lean_box(0); } -x_114 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; -if (lean_is_scalar(x_113)) { - x_115 = lean_alloc_ctor(0, 4, 0); +x_116 = l_Lean_setReducibilityStatus___at_Lean_mkNoConfusionEnum_mkToCtorIdx___spec__14___closed__12; +if (lean_is_scalar(x_115)) { + x_117 = lean_alloc_ctor(0, 4, 0); } else { - x_115 = x_113; + x_117 = x_115; } -lean_ctor_set(x_115, 0, x_110); -lean_ctor_set(x_115, 1, x_114); -lean_ctor_set(x_115, 2, x_111); -lean_ctor_set(x_115, 3, x_112); -x_116 = lean_st_ref_set(x_11, x_115, x_109); -lean_dec(x_11); -x_117 = lean_ctor_get(x_116, 1); -lean_inc(x_117); -if (lean_is_exclusive(x_116)) { - lean_ctor_release(x_116, 0); - lean_ctor_release(x_116, 1); - x_118 = x_116; -} else { - lean_dec_ref(x_116); - x_118 = lean_box(0); -} -x_119 = lean_box(0); -if (lean_is_scalar(x_118)) { - x_120 = lean_alloc_ctor(0, 2, 0); -} else { +lean_ctor_set(x_117, 0, x_112); +lean_ctor_set(x_117, 1, x_116); +lean_ctor_set(x_117, 2, x_113); +lean_ctor_set(x_117, 3, x_114); +x_118 = lean_st_ref_set(x_12, x_117, x_111); +lean_dec(x_12); +x_119 = lean_ctor_get(x_118, 1); +lean_inc(x_119); +if (lean_is_exclusive(x_118)) { + lean_ctor_release(x_118, 0); + lean_ctor_release(x_118, 1); x_120 = x_118; +} else { + lean_dec_ref(x_118); + x_120 = lean_box(0); } -lean_ctor_set(x_120, 0, x_119); -lean_ctor_set(x_120, 1, x_117); -return x_120; +x_121 = lean_box(0); +if (lean_is_scalar(x_120)) { + x_122 = lean_alloc_ctor(0, 2, 0); +} else { + x_122 = x_120; +} +lean_ctor_set(x_122, 0, x_121); +lean_ctor_set(x_122, 1, x_119); +return x_122; } } else { -uint8_t x_121; -lean_dec(x_46); +uint8_t x_123; +lean_dec(x_47); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); -x_121 = !lean_is_exclusive(x_53); -if (x_121 == 0) +x_123 = !lean_is_exclusive(x_55); +if (x_123 == 0) { -return x_53; +return x_55; } else { -lean_object* x_122; lean_object* x_123; lean_object* x_124; -x_122 = lean_ctor_get(x_53, 0); -x_123 = lean_ctor_get(x_53, 1); -lean_inc(x_123); -lean_inc(x_122); -lean_dec(x_53); -x_124 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_124, 0, x_122); -lean_ctor_set(x_124, 1, x_123); -return x_124; +lean_object* x_124; lean_object* x_125; lean_object* x_126; +x_124 = lean_ctor_get(x_55, 0); +x_125 = lean_ctor_get(x_55, 1); +lean_inc(x_125); +lean_inc(x_124); +lean_dec(x_55); +x_126 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_126, 0, x_124); +lean_ctor_set(x_126, 1, x_125); +return x_126; } } } else { -uint8_t x_125; -lean_dec(x_25); +uint8_t x_127; +lean_dec(x_26); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); +lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -x_125 = !lean_is_exclusive(x_42); -if (x_125 == 0) +x_127 = !lean_is_exclusive(x_43); +if (x_127 == 0) { -return x_42; +return x_43; } else { -lean_object* x_126; lean_object* x_127; lean_object* x_128; -x_126 = lean_ctor_get(x_42, 0); -x_127 = lean_ctor_get(x_42, 1); -lean_inc(x_127); -lean_inc(x_126); -lean_dec(x_42); -x_128 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_128, 0, x_126); -lean_ctor_set(x_128, 1, x_127); -return x_128; +lean_object* x_128; lean_object* x_129; lean_object* x_130; +x_128 = lean_ctor_get(x_43, 0); +x_129 = lean_ctor_get(x_43, 1); +lean_inc(x_129); +lean_inc(x_128); +lean_dec(x_43); +x_130 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_130, 0, x_128); +lean_ctor_set(x_130, 1, x_129); +return x_130; } } } else { -uint8_t x_129; -lean_dec(x_25); -lean_dec(x_19); +uint8_t x_131; +lean_dec(x_26); +lean_dec(x_20); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); -lean_dec(x_10); +lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -x_129 = !lean_is_exclusive(x_39); -if (x_129 == 0) +x_131 = !lean_is_exclusive(x_40); +if (x_131 == 0) { -return x_39; +return x_40; } else { -lean_object* x_130; lean_object* x_131; lean_object* x_132; -x_130 = lean_ctor_get(x_39, 0); -x_131 = lean_ctor_get(x_39, 1); -lean_inc(x_131); -lean_inc(x_130); -lean_dec(x_39); -x_132 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_132, 0, x_130); -lean_ctor_set(x_132, 1, x_131); -return x_132; +lean_object* x_132; lean_object* x_133; lean_object* x_134; +x_132 = lean_ctor_get(x_40, 0); +x_133 = lean_ctor_get(x_40, 1); +lean_inc(x_133); +lean_inc(x_132); +lean_dec(x_40); +x_134 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_134, 0, x_132); +lean_ctor_set(x_134, 1, x_133); +return x_134; } } } else { -uint8_t x_133; -lean_dec(x_19); +uint8_t x_135; +lean_dec(x_20); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); @@ -4906,23 +4933,23 @@ lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_133 = !lean_is_exclusive(x_24); -if (x_133 == 0) +x_135 = !lean_is_exclusive(x_25); +if (x_135 == 0) { -return x_24; +return x_25; } else { -lean_object* x_134; lean_object* x_135; lean_object* x_136; -x_134 = lean_ctor_get(x_24, 0); -x_135 = lean_ctor_get(x_24, 1); -lean_inc(x_135); -lean_inc(x_134); -lean_dec(x_24); -x_136 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_136, 0, x_134); -lean_ctor_set(x_136, 1, x_135); -return x_136; +lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_136 = lean_ctor_get(x_25, 0); +x_137 = lean_ctor_get(x_25, 1); +lean_inc(x_137); +lean_inc(x_136); +lean_dec(x_25); +x_138 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_138, 0, x_136); +lean_ctor_set(x_138, 1, x_137); +return x_138; } } } @@ -4945,42 +4972,44 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { _start: { -lean_object* x_14; +lean_object* x_15; +lean_inc(x_13); lean_inc(x_12); lean_inc(x_11); lean_inc(x_10); lean_inc(x_9); -lean_inc(x_8); lean_inc(x_1); -x_14 = l_Lean_Meta_mkEq(x_1, x_8, x_9, x_10, x_11, x_12, x_13); -if (lean_obj_tag(x_14) == 0) +x_15 = l_Lean_Meta_mkEq(x_1, x_9, x_10, x_11, x_12, x_13, x_14); +if (lean_obj_tag(x_15) == 0) { -lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; -x_15 = lean_ctor_get(x_14, 0); -lean_inc(x_15); -x_16 = lean_ctor_get(x_14, 1); +lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; +x_16 = lean_ctor_get(x_15, 0); lean_inc(x_16); -lean_dec(x_14); -x_17 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1), 14, 8); -lean_closure_set(x_17, 0, x_2); -lean_closure_set(x_17, 1, x_1); -lean_closure_set(x_17, 2, x_8); -lean_closure_set(x_17, 3, x_3); -lean_closure_set(x_17, 4, x_4); -lean_closure_set(x_17, 5, x_5); -lean_closure_set(x_17, 6, x_6); -lean_closure_set(x_17, 7, x_7); -x_18 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2___closed__2; -x_19 = 0; -x_20 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_18, x_19, x_15, x_17, x_9, x_10, x_11, x_12, x_16); -return x_20; +x_17 = lean_ctor_get(x_15, 1); +lean_inc(x_17); +lean_dec(x_15); +x_18 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__1), 15, 9); +lean_closure_set(x_18, 0, x_2); +lean_closure_set(x_18, 1, x_1); +lean_closure_set(x_18, 2, x_9); +lean_closure_set(x_18, 3, x_3); +lean_closure_set(x_18, 4, x_4); +lean_closure_set(x_18, 5, x_5); +lean_closure_set(x_18, 6, x_6); +lean_closure_set(x_18, 7, x_7); +lean_closure_set(x_18, 8, x_8); +x_19 = l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2___closed__2; +x_20 = 0; +x_21 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_19, x_20, x_16, x_18, x_10, x_11, x_12, x_13, x_17); +return x_21; } else { -uint8_t x_21; +uint8_t x_22; +lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -4993,32 +5022,52 @@ lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_21 = !lean_is_exclusive(x_14); -if (x_21 == 0) +x_22 = !lean_is_exclusive(x_15); +if (x_22 == 0) { -return x_14; +return x_15; } else { -lean_object* x_22; lean_object* x_23; lean_object* x_24; -x_22 = lean_ctor_get(x_14, 0); -x_23 = lean_ctor_get(x_14, 1); +lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_23 = lean_ctor_get(x_15, 0); +x_24 = lean_ctor_get(x_15, 1); +lean_inc(x_24); lean_inc(x_23); -lean_inc(x_22); -lean_dec(x_14); -x_24 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_24, 0, x_22); -lean_ctor_set(x_24, 1, x_23); -return x_24; +lean_dec(x_15); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_23); +lean_ctor_set(x_25, 1, x_24); +return x_25; } } } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14) { +_start: +{ +lean_object* x_15; lean_object* x_16; uint8_t x_17; lean_object* x_18; +x_15 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2), 14, 8); +lean_closure_set(x_15, 0, x_9); +lean_closure_set(x_15, 1, x_1); +lean_closure_set(x_15, 2, x_2); +lean_closure_set(x_15, 3, x_3); +lean_closure_set(x_15, 4, x_4); +lean_closure_set(x_15, 5, x_5); +lean_closure_set(x_15, 6, x_6); +lean_closure_set(x_15, 7, x_7); +x_16 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2___closed__2; +x_17 = 1; +x_18 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_16, x_17, x_8, x_15, x_10, x_11, x_12, x_13, x_14); +return x_18; +} +} +LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { _start: { lean_object* x_14; lean_object* x_15; uint8_t x_16; lean_object* x_17; -x_14 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__2), 13, 7); +lean_inc(x_7); +x_14 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__3), 14, 8); lean_closure_set(x_14, 0, x_8); lean_closure_set(x_14, 1, x_1); lean_closure_set(x_14, 2, x_2); @@ -5026,31 +5075,13 @@ lean_closure_set(x_14, 3, x_3); lean_closure_set(x_14, 4, x_4); lean_closure_set(x_14, 5, x_5); lean_closure_set(x_14, 6, x_6); -x_15 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___lambda__2___closed__2; +lean_closure_set(x_14, 7, x_7); +x_15 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___closed__11; x_16 = 1; x_17 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_15, x_16, x_7, x_14, x_9, x_10, x_11, x_12, x_13); return x_17; } } -LEAN_EXPORT lean_object* l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { -_start: -{ -lean_object* x_13; lean_object* x_14; uint8_t x_15; lean_object* x_16; -lean_inc(x_6); -x_13 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__3), 13, 7); -lean_closure_set(x_13, 0, x_7); -lean_closure_set(x_13, 1, x_1); -lean_closure_set(x_13, 2, x_2); -lean_closure_set(x_13, 3, x_3); -lean_closure_set(x_13, 4, x_4); -lean_closure_set(x_13, 5, x_5); -lean_closure_set(x_13, 6, x_6); -x_14 = l_Lean_mkNoConfusionEnum_mkToCtorIdx___closed__11; -x_15 = 1; -x_16 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_14, x_15, x_6, x_13, x_8, x_9, x_10, x_11, x_12); -return x_16; -} -} static lean_object* _init_l_Lean_mkNoConfusionEnum_mkNoConfusion___closed__1() { _start: { @@ -5127,13 +5158,14 @@ x_27 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_27, 0, x_20); lean_ctor_set(x_27, 1, x_14); x_28 = l_Lean_mkConst(x_26, x_27); -x_29 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__4), 12, 6); +x_29 = lean_alloc_closure((void*)(l_Lean_mkNoConfusionEnum_mkNoConfusion___lambda__4), 13, 7); lean_closure_set(x_29, 0, x_28); lean_closure_set(x_29, 1, x_24); lean_closure_set(x_29, 2, x_1); lean_closure_set(x_29, 3, x_17); lean_closure_set(x_29, 4, x_12); -lean_closure_set(x_29, 5, x_19); +lean_closure_set(x_29, 5, x_13); +lean_closure_set(x_29, 6, x_19); x_30 = l_Lean_mkNoConfusionEnum_mkNoConfusionType___closed__6; x_31 = 1; x_32 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_30, x_31, x_21, x_29, x_2, x_3, x_4, x_5, x_18); diff --git a/stage0/stdlib/Lean/Meta/Eqns.c b/stage0/stdlib/Lean/Meta/Eqns.c index 3e746b0073..7858207059 100644 --- a/stage0/stdlib/Lean/Meta/Eqns.c +++ b/stage0/stdlib/Lean/Meta/Eqns.c @@ -1804,7 +1804,7 @@ lean_dec(x_28); x_31 = l_Lean_Meta_mkLambdaFVars(x_3, x_29, x_22, x_23, x_24, x_5, x_6, x_7, x_8, x_30); if (lean_obj_tag(x_31) == 0) { -lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_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_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; x_32 = lean_ctor_get(x_31, 0); lean_inc(x_32); x_33 = lean_ctor_get(x_31, 1); @@ -1826,67 +1826,72 @@ lean_dec(x_38); lean_inc(x_40); lean_ctor_set(x_10, 2, x_26); lean_ctor_set(x_10, 0, x_40); -x_41 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_41, 0, x_10); -lean_ctor_set(x_41, 1, x_32); -x_42 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_42, 0, x_41); -x_43 = l_Lean_addDecl___at___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___spec__1(x_42, x_5, x_6, x_7, x_8, x_36); -if (lean_obj_tag(x_43) == 0) +lean_inc(x_40); +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_15); +x_42 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_42, 0, x_10); +lean_ctor_set(x_42, 1, x_32); +lean_ctor_set(x_42, 2, x_41); +x_43 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_43, 0, x_42); +x_44 = l_Lean_addDecl___at___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___spec__1(x_43, x_5, x_6, x_7, x_8, x_36); +if (lean_obj_tag(x_44) == 0) { -uint8_t x_44; -x_44 = !lean_is_exclusive(x_43); -if (x_44 == 0) +uint8_t x_45; +x_45 = !lean_is_exclusive(x_44); +if (x_45 == 0) { -lean_object* x_45; lean_object* x_46; -x_45 = lean_ctor_get(x_43, 0); -lean_dec(x_45); -x_46 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_46, 0, x_40); -lean_ctor_set(x_43, 0, x_46); -return x_43; +lean_object* x_46; lean_object* x_47; +x_46 = lean_ctor_get(x_44, 0); +lean_dec(x_46); +x_47 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_47, 0, x_40); +lean_ctor_set(x_44, 0, x_47); +return x_44; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -x_47 = lean_ctor_get(x_43, 1); -lean_inc(x_47); -lean_dec(x_43); -x_48 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_48, 0, x_40); -x_49 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_49, 0, x_48); -lean_ctor_set(x_49, 1, x_47); -return x_49; +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_44, 1); +lean_inc(x_48); +lean_dec(x_44); +x_49 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_49, 0, x_40); +x_50 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_50, 0, x_49); +lean_ctor_set(x_50, 1, x_48); +return x_50; } } else { -uint8_t x_50; +uint8_t x_51; lean_dec(x_40); -x_50 = !lean_is_exclusive(x_43); -if (x_50 == 0) +x_51 = !lean_is_exclusive(x_44); +if (x_51 == 0) { -return x_43; +return x_44; } else { -lean_object* x_51; lean_object* x_52; lean_object* x_53; -x_51 = lean_ctor_get(x_43, 0); -x_52 = lean_ctor_get(x_43, 1); +lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_44, 0); +x_53 = lean_ctor_get(x_44, 1); +lean_inc(x_53); lean_inc(x_52); -lean_inc(x_51); -lean_dec(x_43); -x_53 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_53, 0, x_51); -lean_ctor_set(x_53, 1, x_52); -return x_53; +lean_dec(x_44); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +return x_54; } } } else { -uint8_t x_54; +uint8_t x_55; lean_dec(x_26); lean_free_object(x_10); lean_dec(x_13); @@ -1895,29 +1900,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); -x_54 = !lean_is_exclusive(x_31); -if (x_54 == 0) +x_55 = !lean_is_exclusive(x_31); +if (x_55 == 0) { return x_31; } else { -lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_55 = lean_ctor_get(x_31, 0); -x_56 = lean_ctor_get(x_31, 1); +lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_56 = lean_ctor_get(x_31, 0); +x_57 = lean_ctor_get(x_31, 1); +lean_inc(x_57); lean_inc(x_56); -lean_inc(x_55); lean_dec(x_31); -x_57 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_57, 0, x_55); -lean_ctor_set(x_57, 1, x_56); -return x_57; +x_58 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_58, 0, x_56); +lean_ctor_set(x_58, 1, x_57); +return x_58; } } } else { -uint8_t x_58; +uint8_t x_59; lean_dec(x_26); lean_free_object(x_10); lean_dec(x_13); @@ -1927,29 +1932,29 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_58 = !lean_is_exclusive(x_28); -if (x_58 == 0) +x_59 = !lean_is_exclusive(x_28); +if (x_59 == 0) { return x_28; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_59 = lean_ctor_get(x_28, 0); -x_60 = lean_ctor_get(x_28, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_60 = lean_ctor_get(x_28, 0); +x_61 = lean_ctor_get(x_28, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); lean_dec(x_28); -x_61 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_61, 0, x_59); -lean_ctor_set(x_61, 1, x_60); -return x_61; +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +return x_62; } } } else { -uint8_t x_62; +uint8_t x_63; lean_dec(x_18); lean_free_object(x_10); lean_dec(x_13); @@ -1959,29 +1964,29 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_62 = !lean_is_exclusive(x_25); -if (x_62 == 0) +x_63 = !lean_is_exclusive(x_25); +if (x_63 == 0) { return x_25; } else { -lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_63 = lean_ctor_get(x_25, 0); -x_64 = lean_ctor_get(x_25, 1); +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_25, 0); +x_65 = lean_ctor_get(x_25, 1); +lean_inc(x_65); lean_inc(x_64); -lean_inc(x_63); lean_dec(x_25); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_63); -lean_ctor_set(x_65, 1, x_64); -return x_65; +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; } } } else { -uint8_t x_66; +uint8_t x_67; lean_dec(x_18); lean_free_object(x_10); lean_dec(x_13); @@ -1991,292 +1996,297 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_66 = !lean_is_exclusive(x_19); -if (x_66 == 0) +x_67 = !lean_is_exclusive(x_19); +if (x_67 == 0) { return x_19; } else { -lean_object* x_67; lean_object* x_68; lean_object* x_69; -x_67 = lean_ctor_get(x_19, 0); -x_68 = lean_ctor_get(x_19, 1); +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_19, 0); +x_69 = lean_ctor_get(x_19, 1); +lean_inc(x_69); lean_inc(x_68); -lean_inc(x_67); lean_dec(x_19); -x_69 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_69, 0, x_67); -lean_ctor_set(x_69, 1, x_68); -return x_69; +x_70 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set(x_70, 1, x_69); +return x_70; } } } else { -lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; -x_70 = lean_ctor_get(x_10, 0); -x_71 = lean_ctor_get(x_10, 1); +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_71 = lean_ctor_get(x_10, 0); +x_72 = lean_ctor_get(x_10, 1); +lean_inc(x_72); lean_inc(x_71); -lean_inc(x_70); lean_dec(x_10); -x_72 = lean_box(0); -lean_inc(x_71); -x_73 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_71, x_72); -x_74 = l_Lean_mkConst(x_70, x_73); +x_73 = lean_box(0); +lean_inc(x_72); +x_74 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_72, x_73); +x_75 = l_Lean_mkConst(x_71, x_74); lean_inc(x_3); -x_75 = l_Lean_mkAppN(x_74, x_3); +x_76 = l_Lean_mkAppN(x_75, x_3); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -lean_inc(x_75); -x_76 = l_Lean_Meta_mkEq(x_75, x_4, x_5, x_6, x_7, x_8, x_9); -if (lean_obj_tag(x_76) == 0) +lean_inc(x_76); +x_77 = l_Lean_Meta_mkEq(x_76, x_4, x_5, x_6, x_7, x_8, x_9); +if (lean_obj_tag(x_77) == 0) { -lean_object* x_77; lean_object* x_78; uint8_t x_79; uint8_t x_80; uint8_t x_81; lean_object* x_82; -x_77 = lean_ctor_get(x_76, 0); -lean_inc(x_77); -x_78 = lean_ctor_get(x_76, 1); +lean_object* x_78; lean_object* x_79; uint8_t x_80; uint8_t x_81; uint8_t x_82; lean_object* x_83; +x_78 = lean_ctor_get(x_77, 0); lean_inc(x_78); -lean_dec(x_76); -x_79 = 0; -x_80 = 1; +x_79 = lean_ctor_get(x_77, 1); +lean_inc(x_79); +lean_dec(x_77); +x_80 = 0; x_81 = 1; +x_82 = 1; lean_inc(x_3); -x_82 = l_Lean_Meta_mkForallFVars(x_3, x_77, x_79, x_80, x_81, x_5, x_6, x_7, x_8, x_78); -if (lean_obj_tag(x_82) == 0) +x_83 = l_Lean_Meta_mkForallFVars(x_3, x_78, x_80, x_81, x_82, x_5, x_6, x_7, x_8, x_79); +if (lean_obj_tag(x_83) == 0) { -lean_object* x_83; lean_object* x_84; lean_object* x_85; -x_83 = lean_ctor_get(x_82, 0); -lean_inc(x_83); -x_84 = lean_ctor_get(x_82, 1); +lean_object* x_84; lean_object* x_85; lean_object* x_86; +x_84 = lean_ctor_get(x_83, 0); lean_inc(x_84); -lean_dec(x_82); +x_85 = lean_ctor_get(x_83, 1); +lean_inc(x_85); +lean_dec(x_83); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); -x_85 = l_Lean_Meta_mkEqRefl(x_75, x_5, x_6, x_7, x_8, x_84); -if (lean_obj_tag(x_85) == 0) +x_86 = l_Lean_Meta_mkEqRefl(x_76, x_5, x_6, x_7, x_8, x_85); +if (lean_obj_tag(x_86) == 0) { -lean_object* x_86; lean_object* x_87; lean_object* x_88; -x_86 = lean_ctor_get(x_85, 0); -lean_inc(x_86); -x_87 = lean_ctor_get(x_85, 1); +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_86, 0); lean_inc(x_87); -lean_dec(x_85); -x_88 = l_Lean_Meta_mkLambdaFVars(x_3, x_86, x_79, x_80, x_81, x_5, x_6, x_7, x_8, x_87); -if (lean_obj_tag(x_88) == 0) +x_88 = lean_ctor_get(x_86, 1); +lean_inc(x_88); +lean_dec(x_86); +x_89 = l_Lean_Meta_mkLambdaFVars(x_3, x_87, x_80, x_81, x_82, x_5, x_6, x_7, x_8, x_88); +if (lean_obj_tag(x_89) == 0) { -lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; -x_89 = lean_ctor_get(x_88, 0); -lean_inc(x_89); -x_90 = lean_ctor_get(x_88, 1); +lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; lean_object* x_103; +x_90 = lean_ctor_get(x_89, 0); lean_inc(x_90); -lean_dec(x_88); -x_91 = lean_st_ref_get(x_8, x_90); -x_92 = lean_ctor_get(x_91, 0); -lean_inc(x_92); -x_93 = lean_ctor_get(x_91, 1); +x_91 = lean_ctor_get(x_89, 1); +lean_inc(x_91); +lean_dec(x_89); +x_92 = lean_st_ref_get(x_8, x_91); +x_93 = lean_ctor_get(x_92, 0); lean_inc(x_93); -lean_dec(x_91); -x_94 = lean_ctor_get(x_92, 0); +x_94 = lean_ctor_get(x_92, 1); lean_inc(x_94); lean_dec(x_92); -x_95 = l_Lean_mkPrivateName(x_94, x_2); -x_96 = l___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___lambda__1___closed__2; -x_97 = l_Lean_Name_append(x_95, x_96); -lean_dec(x_95); -lean_inc(x_97); -x_98 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_98, 0, x_97); -lean_ctor_set(x_98, 1, x_71); -lean_ctor_set(x_98, 2, x_83); -x_99 = lean_alloc_ctor(0, 2, 0); +x_95 = lean_ctor_get(x_93, 0); +lean_inc(x_95); +lean_dec(x_93); +x_96 = l_Lean_mkPrivateName(x_95, x_2); +x_97 = l___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___lambda__1___closed__2; +x_98 = l_Lean_Name_append(x_96, x_97); +lean_dec(x_96); +lean_inc(x_98); +x_99 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_99, 0, x_98); -lean_ctor_set(x_99, 1, x_89); -x_100 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_100, 0, x_99); -x_101 = l_Lean_addDecl___at___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___spec__1(x_100, x_5, x_6, x_7, x_8, x_93); -if (lean_obj_tag(x_101) == 0) +lean_ctor_set(x_99, 1, x_72); +lean_ctor_set(x_99, 2, x_84); +lean_inc(x_98); +x_100 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_73); +x_101 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_101, 0, x_99); +lean_ctor_set(x_101, 1, x_90); +lean_ctor_set(x_101, 2, x_100); +x_102 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_102, 0, x_101); +x_103 = l_Lean_addDecl___at___private_Lean_Meta_Eqns_0__Lean_Meta_mkSimpleEqThm___spec__1(x_102, x_5, x_6, x_7, x_8, x_94); +if (lean_obj_tag(x_103) == 0) { -lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; -x_102 = lean_ctor_get(x_101, 1); -lean_inc(x_102); -if (lean_is_exclusive(x_101)) { - lean_ctor_release(x_101, 0); - lean_ctor_release(x_101, 1); - x_103 = x_101; -} else { - lean_dec_ref(x_101); - x_103 = lean_box(0); -} -x_104 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_104, 0, x_97); -if (lean_is_scalar(x_103)) { - x_105 = lean_alloc_ctor(0, 2, 0); -} else { +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; +x_104 = lean_ctor_get(x_103, 1); +lean_inc(x_104); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); x_105 = x_103; +} else { + lean_dec_ref(x_103); + x_105 = lean_box(0); } -lean_ctor_set(x_105, 0, x_104); -lean_ctor_set(x_105, 1, x_102); -return x_105; +x_106 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_106, 0, x_98); +if (lean_is_scalar(x_105)) { + x_107 = lean_alloc_ctor(0, 2, 0); +} else { + x_107 = x_105; +} +lean_ctor_set(x_107, 0, x_106); +lean_ctor_set(x_107, 1, x_104); +return x_107; } else { -lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; -lean_dec(x_97); -x_106 = lean_ctor_get(x_101, 0); -lean_inc(x_106); -x_107 = lean_ctor_get(x_101, 1); -lean_inc(x_107); -if (lean_is_exclusive(x_101)) { - lean_ctor_release(x_101, 0); - lean_ctor_release(x_101, 1); - x_108 = x_101; +lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; +lean_dec(x_98); +x_108 = lean_ctor_get(x_103, 0); +lean_inc(x_108); +x_109 = lean_ctor_get(x_103, 1); +lean_inc(x_109); +if (lean_is_exclusive(x_103)) { + lean_ctor_release(x_103, 0); + lean_ctor_release(x_103, 1); + x_110 = x_103; } else { - lean_dec_ref(x_101); - x_108 = lean_box(0); + lean_dec_ref(x_103); + x_110 = lean_box(0); } -if (lean_is_scalar(x_108)) { - x_109 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_110)) { + x_111 = lean_alloc_ctor(1, 2, 0); } else { - x_109 = x_108; + x_111 = x_110; } -lean_ctor_set(x_109, 0, x_106); -lean_ctor_set(x_109, 1, x_107); -return x_109; +lean_ctor_set(x_111, 0, x_108); +lean_ctor_set(x_111, 1, x_109); +return x_111; } } else { -lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; -lean_dec(x_83); -lean_dec(x_71); +lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; +lean_dec(x_84); +lean_dec(x_72); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_2); -x_110 = lean_ctor_get(x_88, 0); -lean_inc(x_110); -x_111 = lean_ctor_get(x_88, 1); -lean_inc(x_111); -if (lean_is_exclusive(x_88)) { - lean_ctor_release(x_88, 0); - lean_ctor_release(x_88, 1); - x_112 = x_88; +x_112 = lean_ctor_get(x_89, 0); +lean_inc(x_112); +x_113 = lean_ctor_get(x_89, 1); +lean_inc(x_113); +if (lean_is_exclusive(x_89)) { + lean_ctor_release(x_89, 0); + lean_ctor_release(x_89, 1); + x_114 = x_89; } else { - lean_dec_ref(x_88); - x_112 = lean_box(0); + lean_dec_ref(x_89); + x_114 = lean_box(0); } -if (lean_is_scalar(x_112)) { - x_113 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_114)) { + x_115 = lean_alloc_ctor(1, 2, 0); } else { - x_113 = x_112; + x_115 = x_114; } -lean_ctor_set(x_113, 0, x_110); -lean_ctor_set(x_113, 1, x_111); -return x_113; +lean_ctor_set(x_115, 0, x_112); +lean_ctor_set(x_115, 1, x_113); +return x_115; } } else { -lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; -lean_dec(x_83); -lean_dec(x_71); +lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; +lean_dec(x_84); +lean_dec(x_72); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_114 = lean_ctor_get(x_85, 0); -lean_inc(x_114); -x_115 = lean_ctor_get(x_85, 1); -lean_inc(x_115); -if (lean_is_exclusive(x_85)) { - lean_ctor_release(x_85, 0); - lean_ctor_release(x_85, 1); - x_116 = x_85; +x_116 = lean_ctor_get(x_86, 0); +lean_inc(x_116); +x_117 = lean_ctor_get(x_86, 1); +lean_inc(x_117); +if (lean_is_exclusive(x_86)) { + lean_ctor_release(x_86, 0); + lean_ctor_release(x_86, 1); + x_118 = x_86; } else { - lean_dec_ref(x_85); - x_116 = lean_box(0); + lean_dec_ref(x_86); + x_118 = lean_box(0); } -if (lean_is_scalar(x_116)) { - x_117 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_118)) { + x_119 = lean_alloc_ctor(1, 2, 0); } else { - x_117 = x_116; + x_119 = x_118; } -lean_ctor_set(x_117, 0, x_114); -lean_ctor_set(x_117, 1, x_115); -return x_117; +lean_ctor_set(x_119, 0, x_116); +lean_ctor_set(x_119, 1, x_117); +return x_119; } } else { -lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; -lean_dec(x_75); -lean_dec(x_71); +lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; +lean_dec(x_76); +lean_dec(x_72); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_118 = lean_ctor_get(x_82, 0); -lean_inc(x_118); -x_119 = lean_ctor_get(x_82, 1); -lean_inc(x_119); -if (lean_is_exclusive(x_82)) { - lean_ctor_release(x_82, 0); - lean_ctor_release(x_82, 1); - x_120 = x_82; +x_120 = lean_ctor_get(x_83, 0); +lean_inc(x_120); +x_121 = lean_ctor_get(x_83, 1); +lean_inc(x_121); +if (lean_is_exclusive(x_83)) { + lean_ctor_release(x_83, 0); + lean_ctor_release(x_83, 1); + x_122 = x_83; } else { - lean_dec_ref(x_82); - x_120 = lean_box(0); + lean_dec_ref(x_83); + x_122 = lean_box(0); } -if (lean_is_scalar(x_120)) { - x_121 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_122)) { + x_123 = lean_alloc_ctor(1, 2, 0); } else { - x_121 = x_120; + x_123 = x_122; } -lean_ctor_set(x_121, 0, x_118); -lean_ctor_set(x_121, 1, x_119); -return x_121; +lean_ctor_set(x_123, 0, x_120); +lean_ctor_set(x_123, 1, x_121); +return x_123; } } else { -lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; -lean_dec(x_75); -lean_dec(x_71); +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; +lean_dec(x_76); +lean_dec(x_72); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_3); lean_dec(x_2); -x_122 = lean_ctor_get(x_76, 0); -lean_inc(x_122); -x_123 = lean_ctor_get(x_76, 1); -lean_inc(x_123); -if (lean_is_exclusive(x_76)) { - lean_ctor_release(x_76, 0); - lean_ctor_release(x_76, 1); - x_124 = x_76; +x_124 = lean_ctor_get(x_77, 0); +lean_inc(x_124); +x_125 = lean_ctor_get(x_77, 1); +lean_inc(x_125); +if (lean_is_exclusive(x_77)) { + lean_ctor_release(x_77, 0); + lean_ctor_release(x_77, 1); + x_126 = x_77; } else { - lean_dec_ref(x_76); - x_124 = lean_box(0); + lean_dec_ref(x_77); + x_126 = lean_box(0); } -if (lean_is_scalar(x_124)) { - x_125 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_126)) { + x_127 = lean_alloc_ctor(1, 2, 0); } else { - x_125 = x_124; + x_127 = x_126; } -lean_ctor_set(x_125, 0, x_122); -lean_ctor_set(x_125, 1, x_123); -return x_125; +lean_ctor_set(x_127, 0, x_124); +lean_ctor_set(x_127, 1, x_125); +return x_127; } } } diff --git a/stage0/stdlib/Lean/Meta/IndPredBelow.c b/stage0/stdlib/Lean/Meta/IndPredBelow.c index 43b5d81e21..5bd2133767 100644 --- a/stage0/stdlib/Lean/Meta/IndPredBelow.c +++ b/stage0/stdlib/Lean/Meta/IndPredBelow.c @@ -11824,167 +11824,185 @@ uint8_t x_22; x_22 = !lean_is_exclusive(x_21); if (x_22 == 0) { -lean_object* x_23; lean_object* x_24; lean_object* x_25; +lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; x_23 = lean_ctor_get(x_21, 0); +lean_inc(x_20); lean_ctor_set(x_14, 2, x_9); lean_ctor_set(x_14, 0, x_20); -x_24 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_24, 0, x_14); -lean_ctor_set(x_24, 1, x_23); -x_25 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_25, 0, x_24); -lean_ctor_set(x_21, 0, x_25); +x_24 = lean_box(0); +x_25 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_25, 0, x_20); +lean_ctor_set(x_25, 1, x_24); +x_26 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_26, 0, x_14); +lean_ctor_set(x_26, 1, x_23); +lean_ctor_set(x_26, 2, x_25); +x_27 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_21, 0, x_27); return x_21; } else { -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_21, 0); -x_27 = lean_ctor_get(x_21, 1); -lean_inc(x_27); -lean_inc(x_26); +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +x_28 = lean_ctor_get(x_21, 0); +x_29 = lean_ctor_get(x_21, 1); +lean_inc(x_29); +lean_inc(x_28); lean_dec(x_21); +lean_inc(x_20); lean_ctor_set(x_14, 2, x_9); lean_ctor_set(x_14, 0, x_20); -x_28 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_28, 0, x_14); -lean_ctor_set(x_28, 1, x_26); -x_29 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_29, 0, x_28); -x_30 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_30, 0, x_29); -lean_ctor_set(x_30, 1, x_27); -return x_30; +x_30 = lean_box(0); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_20); +lean_ctor_set(x_31, 1, x_30); +x_32 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_32, 0, x_14); +lean_ctor_set(x_32, 1, x_28); +lean_ctor_set(x_32, 2, x_31); +x_33 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_34, 0, x_33); +lean_ctor_set(x_34, 1, x_29); +return x_34; } } else { -uint8_t x_31; +uint8_t x_35; lean_dec(x_20); lean_free_object(x_14); lean_dec(x_17); lean_dec(x_9); -x_31 = !lean_is_exclusive(x_21); -if (x_31 == 0) +x_35 = !lean_is_exclusive(x_21); +if (x_35 == 0) { return x_21; } else { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_32 = lean_ctor_get(x_21, 0); -x_33 = lean_ctor_get(x_21, 1); -lean_inc(x_33); -lean_inc(x_32); -lean_dec(x_21); -x_34 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_34, 0, x_32); -lean_ctor_set(x_34, 1, x_33); -return x_34; -} -} -} -else -{ -lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; -x_35 = lean_ctor_get(x_14, 0); -x_36 = lean_ctor_get(x_14, 1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_36 = lean_ctor_get(x_21, 0); +x_37 = lean_ctor_get(x_21, 1); +lean_inc(x_37); lean_inc(x_36); -lean_inc(x_35); -lean_dec(x_14); -x_37 = l_Lean_Meta_IndPredBelow_mkBrecOnDecl___closed__1; -x_38 = l_Lean_Name_append(x_35, x_37); -lean_dec(x_35); -lean_inc(x_9); -x_39 = l_Lean_Meta_IndPredBelow_proveBrecOn(x_1, x_13, x_9, x_3, x_4, x_5, x_6, x_10); -if (lean_obj_tag(x_39) == 0) +lean_dec(x_21); +x_38 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_38, 0, x_36); +lean_ctor_set(x_38, 1, x_37); +return x_38; +} +} +} +else { -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_40 = lean_ctor_get(x_39, 0); +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_39 = lean_ctor_get(x_14, 0); +x_40 = lean_ctor_get(x_14, 1); lean_inc(x_40); -x_41 = lean_ctor_get(x_39, 1); -lean_inc(x_41); -if (lean_is_exclusive(x_39)) { - lean_ctor_release(x_39, 0); - lean_ctor_release(x_39, 1); - x_42 = x_39; -} else { - lean_dec_ref(x_39); - x_42 = lean_box(0); -} -x_43 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_43, 0, x_38); -lean_ctor_set(x_43, 1, x_36); -lean_ctor_set(x_43, 2, x_9); -x_44 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_44, 0, x_43); -lean_ctor_set(x_44, 1, x_40); -x_45 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_45, 0, x_44); -if (lean_is_scalar(x_42)) { - x_46 = lean_alloc_ctor(0, 2, 0); -} else { - x_46 = x_42; -} -lean_ctor_set(x_46, 0, x_45); -lean_ctor_set(x_46, 1, x_41); -return x_46; -} -else +lean_inc(x_39); +lean_dec(x_14); +x_41 = l_Lean_Meta_IndPredBelow_mkBrecOnDecl___closed__1; +x_42 = l_Lean_Name_append(x_39, x_41); +lean_dec(x_39); +lean_inc(x_9); +x_43 = l_Lean_Meta_IndPredBelow_proveBrecOn(x_1, x_13, x_9, x_3, x_4, x_5, x_6, x_10); +if (lean_obj_tag(x_43) == 0) { -lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; -lean_dec(x_38); -lean_dec(x_36); -lean_dec(x_9); -x_47 = lean_ctor_get(x_39, 0); -lean_inc(x_47); -x_48 = lean_ctor_get(x_39, 1); -lean_inc(x_48); -if (lean_is_exclusive(x_39)) { - lean_ctor_release(x_39, 0); - lean_ctor_release(x_39, 1); - x_49 = x_39; +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; +x_44 = lean_ctor_get(x_43, 0); +lean_inc(x_44); +x_45 = lean_ctor_get(x_43, 1); +lean_inc(x_45); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_46 = x_43; } else { - lean_dec_ref(x_39); - x_49 = lean_box(0); -} -if (lean_is_scalar(x_49)) { - x_50 = lean_alloc_ctor(1, 2, 0); -} else { - x_50 = x_49; + lean_dec_ref(x_43); + x_46 = lean_box(0); } +lean_inc(x_42); +x_47 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_47, 0, x_42); +lean_ctor_set(x_47, 1, x_40); +lean_ctor_set(x_47, 2, x_9); +x_48 = lean_box(0); +x_49 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_49, 0, x_42); +lean_ctor_set(x_49, 1, x_48); +x_50 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_50, 0, x_47); -lean_ctor_set(x_50, 1, x_48); -return x_50; +lean_ctor_set(x_50, 1, x_44); +lean_ctor_set(x_50, 2, x_49); +x_51 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_51, 0, x_50); +if (lean_is_scalar(x_46)) { + x_52 = lean_alloc_ctor(0, 2, 0); +} else { + x_52 = x_46; +} +lean_ctor_set(x_52, 0, x_51); +lean_ctor_set(x_52, 1, x_45); +return x_52; +} +else +{ +lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; +lean_dec(x_42); +lean_dec(x_40); +lean_dec(x_9); +x_53 = lean_ctor_get(x_43, 0); +lean_inc(x_53); +x_54 = lean_ctor_get(x_43, 1); +lean_inc(x_54); +if (lean_is_exclusive(x_43)) { + lean_ctor_release(x_43, 0); + lean_ctor_release(x_43, 1); + x_55 = x_43; +} else { + lean_dec_ref(x_43); + x_55 = lean_box(0); +} +if (lean_is_scalar(x_55)) { + x_56 = lean_alloc_ctor(1, 2, 0); +} else { + x_56 = x_55; +} +lean_ctor_set(x_56, 0, x_53); +lean_ctor_set(x_56, 1, x_54); +return x_56; } } } else { -uint8_t x_51; +uint8_t x_57; lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_51 = !lean_is_exclusive(x_8); -if (x_51 == 0) +x_57 = !lean_is_exclusive(x_8); +if (x_57 == 0) { return x_8; } else { -lean_object* x_52; lean_object* x_53; lean_object* x_54; -x_52 = lean_ctor_get(x_8, 0); -x_53 = lean_ctor_get(x_8, 1); -lean_inc(x_53); -lean_inc(x_52); +lean_object* x_58; lean_object* x_59; lean_object* x_60; +x_58 = lean_ctor_get(x_8, 0); +x_59 = lean_ctor_get(x_8, 1); +lean_inc(x_59); +lean_inc(x_58); lean_dec(x_8); -x_54 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_54, 0, x_52); -lean_ctor_set(x_54, 1, x_53); -return x_54; +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_58); +lean_ctor_set(x_60, 1, x_59); +return x_60; } } } diff --git a/stage0/stdlib/Lean/Meta/Injective.c b/stage0/stdlib/Lean/Meta/Injective.c index 492eb08b52..62f9fd0d2e 100644 --- a/stage0/stdlib/Lean/Meta/Injective.c +++ b/stage0/stdlib/Lean/Meta/Injective.c @@ -26,19 +26,20 @@ lean_object* lean_mk_empty_array_with_capacity(lean_object*); lean_object* l_Lean_Meta_mkForallFVars(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailureHeader___closed__4; lean_object* lean_name_mk_string(lean_object*, lean_object*); +static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__1; lean_object* lean_array_uget(lean_object*, size_t); LEAN_EXPORT lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_panic___at___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq___spec__1___closed__1; lean_object* lean_array_uset(lean_object*, size_t, lean_object*); lean_object* l_Lean_Meta_forallTelescopeReducing___at_Lean_Meta_getParamNames___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lean_Meta_mkInjectiveTheorems___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__1; LEAN_EXPORT lean_object* l_Lean_Meta_elimOptParam___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailureHeader___closed__3; static lean_object* l_Subarray_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f___spec__1___closed__1; lean_object* l_Lean_Meta_addSimpTheorem(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Meta_elimOptParam___lambda__1___closed__2; LEAN_EXPORT lean_object* l_Subarray_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__4; LEAN_EXPORT lean_object* l_Lean_Meta_mkInjectiveTheorems(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Meta_mkInjectiveTheorems___closed__1; lean_object* lean_st_ref_get(lean_object*, lean_object*); @@ -56,8 +57,8 @@ static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailu LEAN_EXPORT lean_object* l_Lean_Meta_elimOptParam(lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___rarg___closed__1; static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_solveEqOfCtorEq___closed__2; -static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__2; LEAN_EXPORT lean_object* l_Lean_Meta_elimOptParam___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); +static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__2; lean_object* l_Lean_Expr_getRevArg_x21(lean_object*, lean_object*); static lean_object* l_Lean_Meta_elimOptParam___lambda__1___closed__1; LEAN_EXPORT lean_object* l_Lean_Meta_withNewBinderInfos___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__3(lean_object*); @@ -90,12 +91,12 @@ lean_object* lean_nat_sub(lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkAnd_x3f(lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_simpExtension; -static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__3; lean_object* l_Lean_Option_register___at_Std_Format_initFn____x40_Lean_Data_Format___hyg_54____spec__1(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_fvarId_x21(lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f_mkArgs2___closed__3; +static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__3; LEAN_EXPORT lean_object* l_Lean_throwError___at___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__2___boxed(lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_injTheoremFailureHeader___closed__2; @@ -106,7 +107,6 @@ LEAN_EXPORT lean_object* l_Lean_throwError___at___private_Lean_Meta_Injective_0_ LEAN_EXPORT lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___lambda__3(lean_object*, lean_object*, lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t l_Lean_Expr_isAppOfArity(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremTypeCore_x3f___spec__1(lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -static lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__4; extern lean_object* l_Lean_instInhabitedExpr; static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__2___closed__7; lean_object* l___private_Init_Util_0__mkPanicMessageWithDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -135,7 +135,7 @@ static lean_object* l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTh lean_object* l_Lean_Meta_substEqs(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Expr_getAppNumArgsAux(lean_object*, lean_object*); lean_object* l_Lean_Meta_assumptionCore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639_(lean_object*); +LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645_(lean_object*); uint8_t lean_expr_eqv(lean_object*, lean_object*); lean_object* l_Lean_throwError___at_Lean_Meta_abstractRange___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Meta_mkInjectiveTheoremNameFor___boxed(lean_object*); @@ -2826,41 +2826,47 @@ lean_inc(x_20); x_23 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremValue(x_20, x_18, x_2, x_3, x_4, x_5, x_17); if (lean_obj_tag(x_23) == 0) { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; x_24 = lean_ctor_get(x_23, 0); lean_inc(x_24); x_25 = lean_ctor_get(x_23, 1); lean_inc(x_25); lean_dec(x_23); -lean_inc(x_3); -x_26 = l_Lean_Meta_instantiateMVars(x_18, x_2, x_3, x_4, x_5, x_25); -x_27 = lean_ctor_get(x_26, 0); -lean_inc(x_27); -x_28 = lean_ctor_get(x_26, 1); -lean_inc(x_28); -lean_dec(x_26); -lean_inc(x_3); -x_29 = l_Lean_Meta_instantiateMVars(x_24, x_2, x_3, x_4, x_5, x_28); -x_30 = lean_ctor_get(x_29, 0); -lean_inc(x_30); -x_31 = lean_ctor_get(x_29, 1); -lean_inc(x_31); -lean_dec(x_29); -x_32 = l_Lean_Meta_mkInjectiveTheoremNameFor(x_20); +x_26 = l_Lean_Meta_mkInjectiveTheoremNameFor(x_20); lean_dec(x_20); -lean_ctor_set(x_16, 2, x_27); -lean_ctor_set(x_16, 0, x_32); -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_16); -lean_ctor_set(x_33, 1, x_30); -x_34 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_34, 0, x_33); -x_35 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_34, x_2, x_3, x_4, x_5, x_31); -return x_35; +lean_inc(x_3); +x_27 = l_Lean_Meta_instantiateMVars(x_18, x_2, x_3, x_4, x_5, x_25); +x_28 = lean_ctor_get(x_27, 0); +lean_inc(x_28); +x_29 = lean_ctor_get(x_27, 1); +lean_inc(x_29); +lean_dec(x_27); +lean_inc(x_3); +x_30 = l_Lean_Meta_instantiateMVars(x_24, x_2, x_3, x_4, x_5, x_29); +x_31 = lean_ctor_get(x_30, 0); +lean_inc(x_31); +x_32 = lean_ctor_get(x_30, 1); +lean_inc(x_32); +lean_dec(x_30); +lean_inc(x_26); +lean_ctor_set(x_16, 2, x_28); +lean_ctor_set(x_16, 0, x_26); +x_33 = lean_box(0); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_26); +lean_ctor_set(x_34, 1, x_33); +x_35 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_35, 0, x_16); +lean_ctor_set(x_35, 1, x_31); +lean_ctor_set(x_35, 2, x_34); +x_36 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_36, 0, x_35); +x_37 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_36, x_2, x_3, x_4, x_5, x_32); +return x_37; } else { -uint8_t x_36; +uint8_t x_38; lean_free_object(x_16); lean_dec(x_21); lean_dec(x_20); @@ -2869,136 +2875,142 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_36 = !lean_is_exclusive(x_23); -if (x_36 == 0) +x_38 = !lean_is_exclusive(x_23); +if (x_38 == 0) { return x_23; } else { -lean_object* x_37; lean_object* x_38; lean_object* x_39; -x_37 = lean_ctor_get(x_23, 0); -x_38 = lean_ctor_get(x_23, 1); -lean_inc(x_38); -lean_inc(x_37); +lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_39 = lean_ctor_get(x_23, 0); +x_40 = lean_ctor_get(x_23, 1); +lean_inc(x_40); +lean_inc(x_39); lean_dec(x_23); -x_39 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_39, 0, x_37); -lean_ctor_set(x_39, 1, x_38); -return x_39; +x_41 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_41, 0, x_39); +lean_ctor_set(x_41, 1, x_40); +return x_41; } } } else { -lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_40 = lean_ctor_get(x_16, 0); -x_41 = lean_ctor_get(x_16, 1); -lean_inc(x_41); -lean_inc(x_40); +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_16, 0); +x_43 = lean_ctor_get(x_16, 1); +lean_inc(x_43); +lean_inc(x_42); lean_dec(x_16); lean_inc(x_5); lean_inc(x_4); lean_inc(x_3); lean_inc(x_2); lean_inc(x_18); -lean_inc(x_40); -x_42 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremValue(x_40, x_18, x_2, x_3, x_4, x_5, x_17); -if (lean_obj_tag(x_42) == 0) +lean_inc(x_42); +x_44 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveTheoremValue(x_42, x_18, x_2, x_3, x_4, x_5, x_17); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_43 = lean_ctor_get(x_42, 0); -lean_inc(x_43); -x_44 = lean_ctor_get(x_42, 1); -lean_inc(x_44); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_45 = lean_ctor_get(x_44, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = l_Lean_Meta_mkInjectiveTheoremNameFor(x_42); lean_dec(x_42); lean_inc(x_3); -x_45 = l_Lean_Meta_instantiateMVars(x_18, x_2, x_3, x_4, x_5, x_44); -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_3); -x_48 = l_Lean_Meta_instantiateMVars(x_43, x_2, x_3, x_4, x_5, x_47); +x_48 = l_Lean_Meta_instantiateMVars(x_18, x_2, x_3, x_4, x_5, x_46); 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); -x_51 = l_Lean_Meta_mkInjectiveTheoremNameFor(x_40); -lean_dec(x_40); -x_52 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_52, 0, x_51); -lean_ctor_set(x_52, 1, x_41); -lean_ctor_set(x_52, 2, x_46); -x_53 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_53, 0, x_52); -lean_ctor_set(x_53, 1, x_49); -x_54 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_54, 0, x_53); -x_55 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_54, x_2, x_3, x_4, x_5, x_50); -return x_55; +lean_inc(x_3); +x_51 = l_Lean_Meta_instantiateMVars(x_45, x_2, x_3, x_4, x_5, x_50); +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_47); +x_54 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_54, 0, x_47); +lean_ctor_set(x_54, 1, x_43); +lean_ctor_set(x_54, 2, x_49); +x_55 = lean_box(0); +x_56 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_56, 0, x_47); +lean_ctor_set(x_56, 1, x_55); +x_57 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_57, 0, x_54); +lean_ctor_set(x_57, 1, x_52); +lean_ctor_set(x_57, 2, x_56); +x_58 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_58, x_2, x_3, x_4, x_5, x_53); +return x_59; } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; -lean_dec(x_41); -lean_dec(x_40); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +lean_dec(x_43); +lean_dec(x_42); lean_dec(x_18); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_56 = lean_ctor_get(x_42, 0); -lean_inc(x_56); -x_57 = lean_ctor_get(x_42, 1); -lean_inc(x_57); -if (lean_is_exclusive(x_42)) { - lean_ctor_release(x_42, 0); - lean_ctor_release(x_42, 1); - x_58 = x_42; +x_60 = lean_ctor_get(x_44, 0); +lean_inc(x_60); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_44)) { + lean_ctor_release(x_44, 0); + lean_ctor_release(x_44, 1); + x_62 = x_44; } else { - lean_dec_ref(x_42); - x_58 = lean_box(0); + lean_dec_ref(x_44); + x_62 = lean_box(0); } -if (lean_is_scalar(x_58)) { - x_59 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_62)) { + x_63 = lean_alloc_ctor(1, 2, 0); } else { - x_59 = x_58; + x_63 = x_62; } -lean_ctor_set(x_59, 0, x_56); -lean_ctor_set(x_59, 1, x_57); -return x_59; +lean_ctor_set(x_63, 0, x_60); +lean_ctor_set(x_63, 1, x_61); +return x_63; } } } } else { -uint8_t x_60; +uint8_t x_64; lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_60 = !lean_is_exclusive(x_8); -if (x_60 == 0) +x_64 = !lean_is_exclusive(x_8); +if (x_64 == 0) { return x_8; } else { -lean_object* x_61; lean_object* x_62; lean_object* x_63; -x_61 = lean_ctor_get(x_8, 0); -x_62 = lean_ctor_get(x_8, 1); -lean_inc(x_62); -lean_inc(x_61); +lean_object* x_65; lean_object* x_66; lean_object* x_67; +x_65 = lean_ctor_get(x_8, 0); +x_66 = lean_ctor_get(x_8, 1); +lean_inc(x_66); +lean_inc(x_65); lean_dec(x_8); -x_63 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_63, 0, x_61); -lean_ctor_set(x_63, 1, x_62); -return x_63; +x_67 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_67, 0, x_65); +lean_ctor_set(x_67, 1, x_66); +return x_67; } } } @@ -3689,7 +3701,7 @@ lean_inc(x_20); x_23 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue(x_20, x_18, x_2, x_3, x_4, x_5, x_17); if (lean_obj_tag(x_23) == 0) { -lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; x_24 = lean_ctor_get(x_23, 0); lean_inc(x_24); x_25 = lean_ctor_get(x_23, 1); @@ -3714,60 +3726,66 @@ lean_dec(x_30); lean_inc(x_26); lean_ctor_set(x_16, 2, x_28); lean_ctor_set(x_16, 0, x_26); -x_33 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_33, 0, x_16); -lean_ctor_set(x_33, 1, x_31); -x_34 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_34, 0, x_33); +x_33 = lean_box(0); +lean_inc(x_26); +x_34 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_34, 0, x_26); +lean_ctor_set(x_34, 1, x_33); +x_35 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_35, 0, x_16); +lean_ctor_set(x_35, 1, x_31); +lean_ctor_set(x_35, 2, x_34); +x_36 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_36, 0, x_35); lean_inc(x_5); lean_inc(x_4); lean_inc(x_3); lean_inc(x_2); -x_35 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_34, x_2, x_3, x_4, x_5, x_32); -if (lean_obj_tag(x_35) == 0) +x_37 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_36, x_2, x_3, x_4, x_5, x_32); +if (lean_obj_tag(x_37) == 0) { -lean_object* x_36; lean_object* x_37; uint8_t x_38; uint8_t x_39; lean_object* x_40; lean_object* x_41; -x_36 = lean_ctor_get(x_35, 1); -lean_inc(x_36); -lean_dec(x_35); -x_37 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1; -x_38 = 0; -x_39 = 0; -x_40 = lean_unsigned_to_nat(1000u); -x_41 = l_Lean_Meta_addSimpTheorem(x_37, x_26, x_7, x_38, x_39, x_40, x_2, x_3, x_4, x_5, x_36); -return x_41; +lean_object* x_38; lean_object* x_39; uint8_t x_40; uint8_t x_41; lean_object* x_42; lean_object* x_43; +x_38 = lean_ctor_get(x_37, 1); +lean_inc(x_38); +lean_dec(x_37); +x_39 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1; +x_40 = 0; +x_41 = 0; +x_42 = lean_unsigned_to_nat(1000u); +x_43 = l_Lean_Meta_addSimpTheorem(x_39, x_26, x_7, x_40, x_41, x_42, x_2, x_3, x_4, x_5, x_38); +return x_43; } else { -uint8_t x_42; +uint8_t x_44; lean_dec(x_26); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_42 = !lean_is_exclusive(x_35); -if (x_42 == 0) +x_44 = !lean_is_exclusive(x_37); +if (x_44 == 0) { -return x_35; +return x_37; } else { -lean_object* x_43; lean_object* x_44; lean_object* x_45; -x_43 = lean_ctor_get(x_35, 0); -x_44 = lean_ctor_get(x_35, 1); -lean_inc(x_44); -lean_inc(x_43); -lean_dec(x_35); -x_45 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_45, 0, x_43); -lean_ctor_set(x_45, 1, x_44); -return x_45; +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_37, 0); +x_46 = lean_ctor_get(x_37, 1); +lean_inc(x_46); +lean_inc(x_45); +lean_dec(x_37); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; } } } else { -uint8_t x_46; +uint8_t x_48; lean_free_object(x_16); lean_dec(x_21); lean_dec(x_20); @@ -3776,143 +3794,117 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_46 = !lean_is_exclusive(x_23); -if (x_46 == 0) +x_48 = !lean_is_exclusive(x_23); +if (x_48 == 0) { return x_23; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -x_47 = lean_ctor_get(x_23, 0); -x_48 = lean_ctor_get(x_23, 1); -lean_inc(x_48); -lean_inc(x_47); +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_23, 0); +x_50 = lean_ctor_get(x_23, 1); +lean_inc(x_50); +lean_inc(x_49); lean_dec(x_23); -x_49 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_49, 0, x_47); -lean_ctor_set(x_49, 1, x_48); -return x_49; +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; } } } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_16, 0); -x_51 = lean_ctor_get(x_16, 1); -lean_inc(x_51); -lean_inc(x_50); +lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_16, 0); +x_53 = lean_ctor_get(x_16, 1); +lean_inc(x_53); +lean_inc(x_52); lean_dec(x_16); lean_inc(x_5); lean_inc(x_4); lean_inc(x_3); lean_inc(x_2); lean_inc(x_18); -lean_inc(x_50); -x_52 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue(x_50, x_18, x_2, x_3, x_4, x_5, x_17); -if (lean_obj_tag(x_52) == 0) +lean_inc(x_52); +x_54 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue(x_52, x_18, x_2, x_3, x_4, x_5, x_17); +if (lean_obj_tag(x_54) == 0) { -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_53 = lean_ctor_get(x_52, 0); -lean_inc(x_53); -x_54 = lean_ctor_get(x_52, 1); -lean_inc(x_54); -lean_dec(x_52); -x_55 = l_Lean_Meta_mkInjectiveEqTheoremNameFor(x_50); -lean_dec(x_50); -lean_inc(x_3); -x_56 = l_Lean_Meta_instantiateMVars(x_18, x_2, x_3, x_4, x_5, x_54); -x_57 = lean_ctor_get(x_56, 0); -lean_inc(x_57); -x_58 = lean_ctor_get(x_56, 1); -lean_inc(x_58); -lean_dec(x_56); -lean_inc(x_3); -x_59 = l_Lean_Meta_instantiateMVars(x_53, x_2, x_3, x_4, x_5, x_58); -x_60 = lean_ctor_get(x_59, 0); -lean_inc(x_60); -x_61 = lean_ctor_get(x_59, 1); -lean_inc(x_61); -lean_dec(x_59); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_55 = lean_ctor_get(x_54, 0); lean_inc(x_55); -x_62 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_62, 0, x_55); -lean_ctor_set(x_62, 1, x_51); -lean_ctor_set(x_62, 2, x_57); -x_63 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_63, 0, x_62); -lean_ctor_set(x_63, 1, x_60); -x_64 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_64, 0, x_63); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +lean_dec(x_54); +x_57 = l_Lean_Meta_mkInjectiveEqTheoremNameFor(x_52); +lean_dec(x_52); +lean_inc(x_3); +x_58 = l_Lean_Meta_instantiateMVars(x_18, x_2, x_3, x_4, x_5, x_56); +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_58, 1); +lean_inc(x_60); +lean_dec(x_58); +lean_inc(x_3); +x_61 = l_Lean_Meta_instantiateMVars(x_55, x_2, x_3, x_4, x_5, x_60); +x_62 = lean_ctor_get(x_61, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_61, 1); +lean_inc(x_63); +lean_dec(x_61); +lean_inc(x_57); +x_64 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_64, 0, x_57); +lean_ctor_set(x_64, 1, x_53); +lean_ctor_set(x_64, 2, x_59); +x_65 = lean_box(0); +lean_inc(x_57); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_57); +lean_ctor_set(x_66, 1, x_65); +x_67 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_67, 0, x_64); +lean_ctor_set(x_67, 1, x_62); +lean_ctor_set(x_67, 2, x_66); +x_68 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_68, 0, x_67); lean_inc(x_5); lean_inc(x_4); lean_inc(x_3); lean_inc(x_2); -x_65 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_64, x_2, x_3, x_4, x_5, x_61); -if (lean_obj_tag(x_65) == 0) +x_69 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_68, x_2, x_3, x_4, x_5, x_63); +if (lean_obj_tag(x_69) == 0) { -lean_object* x_66; lean_object* x_67; uint8_t x_68; uint8_t x_69; lean_object* x_70; lean_object* x_71; -x_66 = lean_ctor_get(x_65, 1); -lean_inc(x_66); -lean_dec(x_65); -x_67 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1; -x_68 = 0; -x_69 = 0; -x_70 = lean_unsigned_to_nat(1000u); -x_71 = l_Lean_Meta_addSimpTheorem(x_67, x_55, x_7, x_68, x_69, x_70, x_2, x_3, x_4, x_5, x_66); -return x_71; -} -else -{ -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; -lean_dec(x_55); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_3); -lean_dec(x_2); -x_72 = lean_ctor_get(x_65, 0); -lean_inc(x_72); -x_73 = lean_ctor_get(x_65, 1); -lean_inc(x_73); -if (lean_is_exclusive(x_65)) { - lean_ctor_release(x_65, 0); - lean_ctor_release(x_65, 1); - x_74 = x_65; -} else { - lean_dec_ref(x_65); - x_74 = lean_box(0); -} -if (lean_is_scalar(x_74)) { - x_75 = lean_alloc_ctor(1, 2, 0); -} else { - x_75 = x_74; -} -lean_ctor_set(x_75, 0, x_72); -lean_ctor_set(x_75, 1, x_73); +lean_object* x_70; lean_object* x_71; uint8_t x_72; uint8_t x_73; lean_object* x_74; lean_object* x_75; +x_70 = lean_ctor_get(x_69, 1); +lean_inc(x_70); +lean_dec(x_69); +x_71 = l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1; +x_72 = 0; +x_73 = 0; +x_74 = lean_unsigned_to_nat(1000u); +x_75 = l_Lean_Meta_addSimpTheorem(x_71, x_57, x_7, x_72, x_73, x_74, x_2, x_3, x_4, x_5, x_70); return x_75; } -} else { lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; -lean_dec(x_51); -lean_dec(x_50); -lean_dec(x_18); +lean_dec(x_57); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_76 = lean_ctor_get(x_52, 0); +x_76 = lean_ctor_get(x_69, 0); lean_inc(x_76); -x_77 = lean_ctor_get(x_52, 1); +x_77 = lean_ctor_get(x_69, 1); lean_inc(x_77); -if (lean_is_exclusive(x_52)) { - lean_ctor_release(x_52, 0); - lean_ctor_release(x_52, 1); - x_78 = x_52; +if (lean_is_exclusive(x_69)) { + lean_ctor_release(x_69, 0); + lean_ctor_release(x_69, 1); + x_78 = x_69; } else { - lean_dec_ref(x_52); + lean_dec_ref(x_69); x_78 = lean_box(0); } if (lean_is_scalar(x_78)) { @@ -3925,38 +3917,70 @@ lean_ctor_set(x_79, 1, x_77); return x_79; } } -} -} else { -uint8_t x_80; +lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +lean_dec(x_53); +lean_dec(x_52); +lean_dec(x_18); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -lean_dec(x_1); -x_80 = !lean_is_exclusive(x_8); -if (x_80 == 0) -{ -return x_8; -} -else -{ -lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_81 = lean_ctor_get(x_8, 0); -x_82 = lean_ctor_get(x_8, 1); -lean_inc(x_82); +x_80 = lean_ctor_get(x_54, 0); +lean_inc(x_80); +x_81 = lean_ctor_get(x_54, 1); lean_inc(x_81); -lean_dec(x_8); -x_83 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_83, 0, x_81); -lean_ctor_set(x_83, 1, x_82); +if (lean_is_exclusive(x_54)) { + lean_ctor_release(x_54, 0); + lean_ctor_release(x_54, 1); + x_82 = x_54; +} else { + lean_dec_ref(x_54); + x_82 = lean_box(0); +} +if (lean_is_scalar(x_82)) { + x_83 = lean_alloc_ctor(1, 2, 0); +} else { + x_83 = x_82; +} +lean_ctor_set(x_83, 0, x_80); +lean_ctor_set(x_83, 1, x_81); return x_83; } } } } -static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__1() { +else +{ +uint8_t x_84; +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +lean_dec(x_2); +lean_dec(x_1); +x_84 = !lean_is_exclusive(x_8); +if (x_84 == 0) +{ +return x_8; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_8, 0); +x_86 = lean_ctor_get(x_8, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_8); +x_87 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set(x_87, 1, x_86); +return x_87; +} +} +} +} +static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__1() { _start: { lean_object* x_1; @@ -3964,17 +3988,17 @@ x_1 = lean_mk_string_from_bytes("genInjectivity", 14); return x_1; } } -static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__2() { +static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__2() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; x_1 = lean_box(0); -x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__1; +x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__1; x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__3() { +static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__3() { _start: { lean_object* x_1; @@ -3982,13 +4006,13 @@ x_1 = lean_mk_string_from_bytes("generate injectivity theorems for inductive dat return x_1; } } -static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__4() { +static lean_object* _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__4() { _start: { uint8_t x_1; lean_object* x_2; lean_object* x_3; lean_object* x_4; lean_object* x_5; x_1 = 1; x_2 = l___private_Lean_Meta_Injective_0__Lean_Meta_throwInjectiveTheoremFailure___rarg___closed__1; -x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__3; +x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__3; x_4 = lean_box(x_1); x_5 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_5, 0, x_4); @@ -3997,12 +4021,12 @@ lean_ctor_set(x_5, 2, x_3); return x_5; } } -LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639_(lean_object* x_1) { +LEAN_EXPORT lean_object* l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645_(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; lean_object* x_4; -x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__2; -x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__4; +x_2 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__2; +x_3 = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__4; x_4 = l_Lean_Option_register___at_Std_Format_initFn____x40_Lean_Data_Format___hyg_54____spec__1(x_2, x_3, x_1); return x_4; } @@ -4730,15 +4754,15 @@ l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda_ lean_mark_persistent(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheoremValue___lambda__2___closed__7); l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1 = _init_l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1(); lean_mark_persistent(l___private_Lean_Meta_Injective_0__Lean_Meta_mkInjectiveEqTheorem___closed__1); -l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__1(); -lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__1); -l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__2(); -lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__2); -l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__3 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__3(); -lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__3); -l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__4 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__4(); -lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639____closed__4); -if (builtin) {res = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1639_(lean_io_mk_world()); +l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__1 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__1(); +lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__1); +l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__2 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__2(); +lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__2); +l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__3 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__3(); +lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__3); +l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__4 = _init_l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__4(); +lean_mark_persistent(l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645____closed__4); +if (builtin) {res = l_Lean_Meta_initFn____x40_Lean_Meta_Injective___hyg_1645_(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; l_Lean_Meta_genInjectivity = lean_io_result_get_value(res); lean_mark_persistent(l_Lean_Meta_genInjectivity); diff --git a/stage0/stdlib/Lean/Meta/Match/Match.c b/stage0/stdlib/Lean/Meta/Match/Match.c index 5bd6d7e433..1a73afde4f 100644 --- a/stage0/stdlib/Lean/Meta/Match/Match.c +++ b/stage0/stdlib/Lean/Meta/Match/Match.c @@ -24556,7 +24556,7 @@ lean_inc(x_28); x_29 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_Match_mkMatcherAuxDefinition___spec__1(x_25, x_28); if (lean_obj_tag(x_29) == 0) { -lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; uint8_t x_35; +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; lean_free_object(x_18); x_30 = lean_ctor_get(x_16, 0); lean_inc(x_30); @@ -24572,150 +24572,156 @@ lean_ctor_set(x_33, 2, x_32); lean_inc(x_32); lean_inc(x_22); x_34 = l_Lean_Environment_hasUnsafe(x_22, x_32); +x_35 = lean_box(0); +lean_inc(x_3); +x_36 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_36, 0, x_3); +lean_ctor_set(x_36, 1, x_35); if (x_34 == 0) { -uint8_t x_71; -lean_inc(x_26); -x_71 = l_Lean_Environment_hasUnsafe(x_22, x_26); -if (x_71 == 0) -{ -uint8_t x_72; -x_72 = 1; -x_35 = x_72; -goto block_70; -} -else -{ uint8_t x_73; -x_73 = 0; -x_35 = x_73; -goto block_70; -} -} -else +lean_inc(x_26); +x_73 = l_Lean_Environment_hasUnsafe(x_22, x_26); +if (x_73 == 0) { uint8_t x_74; -lean_dec(x_22); -x_74 = 0; -x_35 = x_74; -goto block_70; -} -block_70: -{ -lean_object* x_36; lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_60; lean_object* x_61; lean_object* x_62; uint8_t x_63; -x_36 = lean_box(1); -lean_inc(x_26); -x_37 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_37, 0, x_33); -lean_ctor_set(x_37, 1, x_26); -lean_ctor_set(x_37, 2, x_36); -lean_ctor_set_uint8(x_37, sizeof(void*)*3, x_35); -x_38 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_38, 0, x_37); -x_60 = lean_st_ref_get(x_9, x_21); -x_61 = lean_ctor_get(x_60, 0); -lean_inc(x_61); -x_62 = lean_ctor_get(x_61, 3); -lean_inc(x_62); -lean_dec(x_61); -x_63 = lean_ctor_get_uint8(x_62, sizeof(void*)*1); -lean_dec(x_62); -if (x_63 == 0) -{ -lean_object* x_64; -x_64 = lean_ctor_get(x_60, 1); -lean_inc(x_64); -lean_dec(x_60); -x_39 = x_14; -x_40 = x_64; -goto block_59; +x_74 = 1; +x_37 = x_74; +goto block_72; } else { -lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; uint8_t x_69; -x_65 = lean_ctor_get(x_60, 1); -lean_inc(x_65); -lean_dec(x_60); -lean_inc(x_4); -x_66 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_4, x_6, x_7, x_8, x_9, x_65); -x_67 = lean_ctor_get(x_66, 0); -lean_inc(x_67); -x_68 = lean_ctor_get(x_66, 1); -lean_inc(x_68); -lean_dec(x_66); -x_69 = lean_unbox(x_67); -lean_dec(x_67); -x_39 = x_69; -x_40 = x_68; -goto block_59; +uint8_t x_75; +x_75 = 0; +x_37 = x_75; +goto block_72; } -block_59: +} +else { -if (x_39 == 0) +uint8_t x_76; +lean_dec(x_22); +x_76 = 0; +x_37 = x_76; +goto block_72; +} +block_72: { -lean_object* x_41; lean_object* x_42; +lean_object* x_38; lean_object* x_39; lean_object* x_40; uint8_t x_41; lean_object* x_42; lean_object* x_62; lean_object* x_63; lean_object* x_64; uint8_t x_65; +x_38 = lean_box(1); +lean_inc(x_26); +x_39 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_39, 0, x_33); +lean_ctor_set(x_39, 1, x_26); +lean_ctor_set(x_39, 2, x_38); +lean_ctor_set(x_39, 3, x_36); +lean_ctor_set_uint8(x_39, sizeof(void*)*4, x_37); +x_40 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_40, 0, x_39); +x_62 = lean_st_ref_get(x_9, x_21); +x_63 = lean_ctor_get(x_62, 0); +lean_inc(x_63); +x_64 = lean_ctor_get(x_63, 3); +lean_inc(x_64); +lean_dec(x_63); +x_65 = lean_ctor_get_uint8(x_64, sizeof(void*)*1); +lean_dec(x_64); +if (x_65 == 0) +{ +lean_object* x_66; +x_66 = lean_ctor_get(x_62, 1); +lean_inc(x_66); +lean_dec(x_62); +x_41 = x_14; +x_42 = x_66; +goto block_61; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; uint8_t x_71; +x_67 = lean_ctor_get(x_62, 1); +lean_inc(x_67); +lean_dec(x_62); +lean_inc(x_4); +x_68 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_4, x_6, x_7, x_8, x_9, x_67); +x_69 = lean_ctor_get(x_68, 0); +lean_inc(x_69); +x_70 = lean_ctor_get(x_68, 1); +lean_inc(x_70); +lean_dec(x_68); +x_71 = lean_unbox(x_69); +lean_dec(x_69); +x_41 = x_71; +x_42 = x_70; +goto block_61; +} +block_61: +{ +if (x_41 == 0) +{ +lean_object* x_43; lean_object* x_44; lean_dec(x_32); lean_dec(x_26); lean_dec(x_4); -x_41 = lean_box(0); -x_42 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_38, x_28, x_3, x_13, x_16, x_41, x_6, x_7, x_8, x_9, x_40); +x_43 = lean_box(0); +x_44 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_40, x_28, x_3, x_13, x_16, x_43, x_6, x_7, x_8, x_9, x_42); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -return x_42; +return x_44; } else { -lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_inc(x_3); -x_43 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_43, 0, x_3); -x_44 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__14; -x_45 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_45, 0, x_44); -lean_ctor_set(x_45, 1, x_43); -x_46 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__12; +x_45 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_45, 0, x_3); +x_46 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__14; x_47 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_47, 0, x_45); -lean_ctor_set(x_47, 1, x_46); -x_48 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_48, 0, x_32); +lean_ctor_set(x_47, 0, x_46); +lean_ctor_set(x_47, 1, x_45); +x_48 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__12; x_49 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_49, 0, x_47); lean_ctor_set(x_49, 1, x_48); -x_50 = l_Lean_Meta_Match_Unify_assign___closed__7; +x_50 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_50, 0, x_32); x_51 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_51, 0, x_49); lean_ctor_set(x_51, 1, x_50); -x_52 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_52, 0, x_26); +x_52 = l_Lean_Meta_Match_Unify_assign___closed__7; x_53 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_53, 0, x_51); lean_ctor_set(x_53, 1, x_52); -x_54 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_54, 0, x_53); -lean_ctor_set(x_54, 1, x_44); -x_55 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_4, x_54, x_6, x_7, x_8, x_9, x_40); -x_56 = lean_ctor_get(x_55, 0); -lean_inc(x_56); -x_57 = lean_ctor_get(x_55, 1); -lean_inc(x_57); -lean_dec(x_55); -x_58 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_38, x_28, x_3, x_13, x_16, x_56, x_6, x_7, x_8, x_9, x_57); +x_54 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_54, 0, x_26); +x_55 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_55, 0, x_53); +lean_ctor_set(x_55, 1, x_54); +x_56 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_56, 0, x_55); +lean_ctor_set(x_56, 1, x_46); +x_57 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_4, x_56, x_6, x_7, x_8, x_9, x_42); +x_58 = lean_ctor_get(x_57, 0); +lean_inc(x_58); +x_59 = lean_ctor_get(x_57, 1); +lean_inc(x_59); +lean_dec(x_57); +x_60 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_40, x_28, x_3, x_13, x_16, x_58, x_6, x_7, x_8, x_9, x_59); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -lean_dec(x_56); -return x_58; +lean_dec(x_58); +return x_60; } } } } 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; lean_object* x_82; +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_dec(x_28); lean_dec(x_26); lean_dec(x_22); @@ -24725,266 +24731,272 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_4); lean_dec(x_3); -x_75 = lean_ctor_get(x_29, 0); -lean_inc(x_75); +x_77 = lean_ctor_get(x_29, 0); +lean_inc(x_77); lean_dec(x_29); -x_76 = lean_ctor_get(x_16, 3); -lean_inc(x_76); -x_77 = lean_array_to_list(lean_box(0), x_76); -x_78 = l_Lean_mkConst(x_75, x_77); -x_79 = lean_ctor_get(x_16, 4); -lean_inc(x_79); +x_78 = lean_ctor_get(x_16, 3); +lean_inc(x_78); +x_79 = lean_array_to_list(lean_box(0), x_78); +x_80 = l_Lean_mkConst(x_77, x_79); +x_81 = lean_ctor_get(x_16, 4); +lean_inc(x_81); lean_dec(x_16); -x_80 = l_Lean_mkAppN(x_78, x_79); -x_81 = lean_box(0); -x_82 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_82, 0, x_80); -lean_ctor_set(x_82, 1, x_81); -lean_ctor_set(x_18, 0, x_82); +x_82 = l_Lean_mkAppN(x_80, x_81); +x_83 = lean_box(0); +x_84 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_84, 0, x_82); +lean_ctor_set(x_84, 1, x_83); +lean_ctor_set(x_18, 0, x_84); return x_18; } } else { -lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; -x_83 = lean_ctor_get(x_18, 0); -x_84 = lean_ctor_get(x_18, 1); -lean_inc(x_84); -lean_inc(x_83); +lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; +x_85 = lean_ctor_get(x_18, 0); +x_86 = lean_ctor_get(x_18, 1); +lean_inc(x_86); +lean_inc(x_85); lean_dec(x_18); -x_85 = lean_ctor_get(x_83, 0); -lean_inc(x_85); -lean_dec(x_83); -x_86 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__4___closed__2; -x_87 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__2___closed__1; -x_88 = l_Lean_EnvExtensionInterfaceUnsafe_getState___rarg(x_86, x_87, x_85); -x_89 = lean_ctor_get(x_16, 2); -lean_inc(x_89); -x_90 = lean_box(x_13); -lean_inc(x_89); -x_91 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_91, 0, x_89); -lean_ctor_set(x_91, 1, x_90); -lean_inc(x_91); -x_92 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_Match_mkMatcherAuxDefinition___spec__1(x_88, x_91); -if (lean_obj_tag(x_92) == 0) -{ -lean_object* x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; uint8_t x_97; uint8_t x_98; -x_93 = lean_ctor_get(x_16, 0); -lean_inc(x_93); -x_94 = lean_array_to_list(lean_box(0), x_93); -x_95 = lean_ctor_get(x_16, 1); -lean_inc(x_95); -lean_inc(x_95); -lean_inc(x_3); -x_96 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_96, 0, x_3); -lean_ctor_set(x_96, 1, x_94); -lean_ctor_set(x_96, 2, x_95); -lean_inc(x_95); -lean_inc(x_85); -x_97 = l_Lean_Environment_hasUnsafe(x_85, x_95); -if (x_97 == 0) -{ -uint8_t x_134; -lean_inc(x_89); -x_134 = l_Lean_Environment_hasUnsafe(x_85, x_89); -if (x_134 == 0) -{ -uint8_t x_135; -x_135 = 1; -x_98 = x_135; -goto block_133; -} -else -{ -uint8_t x_136; -x_136 = 0; -x_98 = x_136; -goto block_133; -} -} -else -{ -uint8_t x_137; +x_87 = lean_ctor_get(x_85, 0); +lean_inc(x_87); lean_dec(x_85); -x_137 = 0; -x_98 = x_137; -goto block_133; -} -block_133: +x_88 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__4___closed__2; +x_89 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__2___closed__1; +x_90 = l_Lean_EnvExtensionInterfaceUnsafe_getState___rarg(x_88, x_89, x_87); +x_91 = lean_ctor_get(x_16, 2); +lean_inc(x_91); +x_92 = lean_box(x_13); +lean_inc(x_91); +x_93 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set(x_93, 1, x_92); +lean_inc(x_93); +x_94 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_Match_mkMatcherAuxDefinition___spec__1(x_90, x_93); +if (lean_obj_tag(x_94) == 0) { -lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; lean_object* x_103; lean_object* x_123; lean_object* x_124; lean_object* x_125; uint8_t x_126; -x_99 = lean_box(1); -lean_inc(x_89); -x_100 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_100, 0, x_96); -lean_ctor_set(x_100, 1, x_89); -lean_ctor_set(x_100, 2, x_99); -lean_ctor_set_uint8(x_100, sizeof(void*)*3, x_98); -x_101 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_101, 0, x_100); -x_123 = lean_st_ref_get(x_9, x_84); -x_124 = lean_ctor_get(x_123, 0); -lean_inc(x_124); -x_125 = lean_ctor_get(x_124, 3); -lean_inc(x_125); -lean_dec(x_124); -x_126 = lean_ctor_get_uint8(x_125, sizeof(void*)*1); -lean_dec(x_125); -if (x_126 == 0) +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; uint8_t x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; +x_95 = lean_ctor_get(x_16, 0); +lean_inc(x_95); +x_96 = lean_array_to_list(lean_box(0), x_95); +x_97 = lean_ctor_get(x_16, 1); +lean_inc(x_97); +lean_inc(x_97); +lean_inc(x_3); +x_98 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_98, 0, x_3); +lean_ctor_set(x_98, 1, x_96); +lean_ctor_set(x_98, 2, x_97); +lean_inc(x_97); +lean_inc(x_87); +x_99 = l_Lean_Environment_hasUnsafe(x_87, x_97); +x_100 = lean_box(0); +lean_inc(x_3); +x_101 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_101, 0, x_3); +lean_ctor_set(x_101, 1, x_100); +if (x_99 == 0) { -lean_object* x_127; -x_127 = lean_ctor_get(x_123, 1); -lean_inc(x_127); -lean_dec(x_123); -x_102 = x_14; -x_103 = x_127; -goto block_122; +uint8_t x_138; +lean_inc(x_91); +x_138 = l_Lean_Environment_hasUnsafe(x_87, x_91); +if (x_138 == 0) +{ +uint8_t x_139; +x_139 = 1; +x_102 = x_139; +goto block_137; } else { -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_123, 1); -lean_inc(x_128); -lean_dec(x_123); -lean_inc(x_4); -x_129 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_4, x_6, x_7, x_8, x_9, x_128); -x_130 = lean_ctor_get(x_129, 0); -lean_inc(x_130); -x_131 = lean_ctor_get(x_129, 1); -lean_inc(x_131); -lean_dec(x_129); -x_132 = lean_unbox(x_130); -lean_dec(x_130); -x_102 = x_132; -x_103 = x_131; -goto block_122; +uint8_t x_140; +x_140 = 0; +x_102 = x_140; +goto block_137; } -block_122: +} +else { -if (x_102 == 0) +uint8_t x_141; +lean_dec(x_87); +x_141 = 0; +x_102 = x_141; +goto block_137; +} +block_137: { -lean_object* x_104; lean_object* x_105; -lean_dec(x_95); -lean_dec(x_89); +lean_object* x_103; lean_object* x_104; lean_object* x_105; uint8_t x_106; lean_object* x_107; lean_object* x_127; lean_object* x_128; lean_object* x_129; uint8_t x_130; +x_103 = lean_box(1); +lean_inc(x_91); +x_104 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_104, 0, x_98); +lean_ctor_set(x_104, 1, x_91); +lean_ctor_set(x_104, 2, x_103); +lean_ctor_set(x_104, 3, x_101); +lean_ctor_set_uint8(x_104, sizeof(void*)*4, x_102); +x_105 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_105, 0, x_104); +x_127 = lean_st_ref_get(x_9, x_86); +x_128 = lean_ctor_get(x_127, 0); +lean_inc(x_128); +x_129 = lean_ctor_get(x_128, 3); +lean_inc(x_129); +lean_dec(x_128); +x_130 = lean_ctor_get_uint8(x_129, sizeof(void*)*1); +lean_dec(x_129); +if (x_130 == 0) +{ +lean_object* x_131; +x_131 = lean_ctor_get(x_127, 1); +lean_inc(x_131); +lean_dec(x_127); +x_106 = x_14; +x_107 = x_131; +goto block_126; +} +else +{ +lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; uint8_t x_136; +x_132 = lean_ctor_get(x_127, 1); +lean_inc(x_132); +lean_dec(x_127); +lean_inc(x_4); +x_133 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_4, x_6, x_7, x_8, x_9, 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); +x_136 = lean_unbox(x_134); +lean_dec(x_134); +x_106 = x_136; +x_107 = x_135; +goto block_126; +} +block_126: +{ +if (x_106 == 0) +{ +lean_object* x_108; lean_object* x_109; +lean_dec(x_97); +lean_dec(x_91); lean_dec(x_4); -x_104 = lean_box(0); -x_105 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_101, x_91, x_3, x_13, x_16, x_104, x_6, x_7, x_8, x_9, x_103); +x_108 = lean_box(0); +x_109 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_105, x_93, x_3, x_13, x_16, x_108, x_6, x_7, x_8, x_9, x_107); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -return x_105; +return x_109; } else { -lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; +lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; lean_object* x_116; lean_object* x_117; lean_object* x_118; lean_object* x_119; lean_object* x_120; lean_object* x_121; lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_inc(x_3); -x_106 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_106, 0, x_3); -x_107 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__14; -x_108 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_108, 0, x_107); -lean_ctor_set(x_108, 1, x_106); -x_109 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__12; -x_110 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_110, 0, x_108); -lean_ctor_set(x_110, 1, x_109); -x_111 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_111, 0, x_95); +x_110 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_110, 0, x_3); +x_111 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__14; x_112 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_112, 0, x_110); -lean_ctor_set(x_112, 1, x_111); -x_113 = l_Lean_Meta_Match_Unify_assign___closed__7; +lean_ctor_set(x_112, 0, x_111); +lean_ctor_set(x_112, 1, x_110); +x_113 = l___private_Lean_Meta_Match_Match_0__Lean_Meta_Match_withAlts_loop___rarg___closed__12; x_114 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_114, 0, x_112); lean_ctor_set(x_114, 1, x_113); x_115 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_115, 0, x_89); +lean_ctor_set(x_115, 0, x_97); x_116 = lean_alloc_ctor(10, 2, 0); lean_ctor_set(x_116, 0, x_114); lean_ctor_set(x_116, 1, x_115); -x_117 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_117, 0, x_116); -lean_ctor_set(x_117, 1, x_107); -x_118 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_4, x_117, x_6, x_7, x_8, x_9, x_103); -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); -x_121 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_101, x_91, x_3, x_13, x_16, x_119, x_6, x_7, x_8, x_9, x_120); +x_117 = l_Lean_Meta_Match_Unify_assign___closed__7; +x_118 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_118, 0, x_116); +lean_ctor_set(x_118, 1, x_117); +x_119 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_119, 0, x_91); +x_120 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_120, 0, x_118); +lean_ctor_set(x_120, 1, x_119); +x_121 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_121, 0, x_120); +lean_ctor_set(x_121, 1, x_111); +x_122 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_4, x_121, x_6, x_7, x_8, x_9, x_107); +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); +x_125 = l_Lean_Meta_Match_mkMatcherAuxDefinition___lambda__3(x_105, x_93, x_3, x_13, x_16, x_123, x_6, x_7, x_8, x_9, x_124); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -lean_dec(x_119); -return x_121; +lean_dec(x_123); +return x_125; } } } } else { -lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; +lean_object* x_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_dec(x_93); lean_dec(x_91); -lean_dec(x_89); -lean_dec(x_85); +lean_dec(x_87); lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_4); lean_dec(x_3); -x_138 = lean_ctor_get(x_92, 0); -lean_inc(x_138); -lean_dec(x_92); -x_139 = lean_ctor_get(x_16, 3); -lean_inc(x_139); -x_140 = lean_array_to_list(lean_box(0), x_139); -x_141 = l_Lean_mkConst(x_138, x_140); -x_142 = lean_ctor_get(x_16, 4); +x_142 = lean_ctor_get(x_94, 0); lean_inc(x_142); +lean_dec(x_94); +x_143 = lean_ctor_get(x_16, 3); +lean_inc(x_143); +x_144 = lean_array_to_list(lean_box(0), x_143); +x_145 = l_Lean_mkConst(x_142, x_144); +x_146 = lean_ctor_get(x_16, 4); +lean_inc(x_146); lean_dec(x_16); -x_143 = l_Lean_mkAppN(x_141, x_142); -x_144 = lean_box(0); -x_145 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_145, 0, x_143); -lean_ctor_set(x_145, 1, x_144); -x_146 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_146, 0, x_145); -lean_ctor_set(x_146, 1, x_84); -return x_146; +x_147 = l_Lean_mkAppN(x_145, x_146); +x_148 = lean_box(0); +x_149 = lean_alloc_ctor(0, 2, 0); +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_149); +lean_ctor_set(x_150, 1, x_86); +return x_150; } } } else { -uint8_t x_147; +uint8_t x_151; lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_4); lean_dec(x_3); -x_147 = !lean_is_exclusive(x_15); -if (x_147 == 0) +x_151 = !lean_is_exclusive(x_15); +if (x_151 == 0) { return x_15; } else { -lean_object* x_148; lean_object* x_149; lean_object* x_150; -x_148 = lean_ctor_get(x_15, 0); -x_149 = lean_ctor_get(x_15, 1); -lean_inc(x_149); -lean_inc(x_148); +lean_object* x_152; lean_object* x_153; lean_object* x_154; +x_152 = lean_ctor_get(x_15, 0); +x_153 = lean_ctor_get(x_15, 1); +lean_inc(x_153); +lean_inc(x_152); lean_dec(x_15); -x_150 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_150, 0, x_148); -lean_ctor_set(x_150, 1, x_149); -return x_150; +x_154 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_154, 0, x_152); +lean_ctor_set(x_154, 1, x_153); +return x_154; } } } diff --git a/stage0/stdlib/Lean/Meta/Match/MatchEqs.c b/stage0/stdlib/Lean/Meta/Match/MatchEqs.c index ab6725d3ae..85d1f8fa76 100644 --- a/stage0/stdlib/Lean/Meta/Match/MatchEqs.c +++ b/stage0/stdlib/Lean/Meta/Match/MatchEqs.c @@ -23,7 +23,7 @@ static lean_object* l_Lean_addTrace___at___private_Lean_Meta_Match_MatchEqs_0__L lean_object* lean_array_set(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_SimpH_processNextEq___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__7; -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_withSplitterAlts_go___rarg___closed__2; size_t lean_usize_add(size_t, size_t); static lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertCastEqRec___spec__1___closed__3; @@ -209,7 +209,7 @@ static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_subs LEAN_EXPORT lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__15___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Meta_Match_proveCondEqThm_go___lambda__2___closed__4; lean_object* l_Lean_Meta_mkEqRefl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Meta_casesOnStuckLHS_findFVar_x3f___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_mkMap___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_SimpH_processNextEq___lambda__5___closed__1; @@ -310,7 +310,7 @@ lean_object* lean_array_get(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_withNewAlts___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertCastEqRec___spec__6___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_mkLambdaFVars(lean_object*, lean_object*, uint8_t, uint8_t, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Meta_Match_proveCondEqThm_go___lambda__2___closed__9; lean_object* l_Lean_Expr_fvarId_x21(lean_object*); lean_object* l_ST_Prim_Ref_get___boxed(lean_object*, lean_object*, lean_object*, lean_object*); @@ -322,7 +322,7 @@ static lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchE lean_object* l_Std_mkHashMapImp___rarg(lean_object*); lean_object* l_instInhabited___rarg(lean_object*, lean_object*); lean_object* lean_name_append_index_after(lean_object*, lean_object*); -LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Meta_casesOnStuckLHS___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_List_mapTRAux___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__3___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__4___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__5___closed__1; LEAN_EXPORT lean_object* l_Std_PersistentArray_forIn___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_substSomeVar___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -466,7 +466,7 @@ LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_Match static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_simpH_x3f___closed__1; static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__4___closed__3; lean_object* l_Lean_Meta_matchEq_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__12___boxed(lean_object*, lean_object*); lean_object* l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertCastEqRec_go___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -514,7 +514,7 @@ LEAN_EXPORT lean_object* l_Lean_Meta_Match_forallAltTelescope_go___rarg___lambda LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_substSomeVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_SimpH_processNextEq___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_getLocalDecl(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_expr_eqv(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_Meta_withIncRecDepth___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof_convertTemplate___spec__18(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_simpH_x3f___closed__3; @@ -31315,225 +31315,267 @@ return x_18; } } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, size_t x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, size_t x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24, lean_object* x_25) { _start: { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; -x_25 = l_Lean_instInhabitedExpr; -x_26 = lean_array_get(x_25, x_19, x_1); -x_27 = l_Lean_ConstantInfo_name(x_2); -x_28 = l_Lean_mkConst(x_27, x_3); -x_29 = l_Array_ofSubarray___rarg(x_4); -x_30 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__6; -x_31 = lean_array_push(x_30, x_5); -x_32 = l_Array_append___rarg(x_29, x_31); -lean_inc(x_32); -x_33 = l_Array_append___rarg(x_32, x_6); -lean_inc(x_19); -x_34 = l_Array_append___rarg(x_33, x_19); -x_35 = l_Lean_mkAppN(x_28, x_34); -x_36 = l_Lean_mkAppN(x_26, x_7); +lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; +x_26 = l_Lean_instInhabitedExpr; +x_27 = lean_array_get(x_26, x_20, x_1); +x_28 = l_Lean_ConstantInfo_name(x_2); +x_29 = l_Lean_mkConst(x_28, x_3); +x_30 = l_Array_ofSubarray___rarg(x_4); +x_31 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__6; +x_32 = lean_array_push(x_31, x_5); +x_33 = l_Array_append___rarg(x_30, x_32); +lean_inc(x_33); +x_34 = l_Array_append___rarg(x_33, x_6); +lean_inc(x_20); +x_35 = l_Array_append___rarg(x_34, x_20); +x_36 = l_Lean_mkAppN(x_29, x_35); +x_37 = l_Lean_mkAppN(x_27, x_7); +lean_inc(x_24); lean_inc(x_23); lean_inc(x_22); lean_inc(x_21); -lean_inc(x_20); -x_37 = l_Lean_Meta_mkEq(x_35, x_36, x_20, x_21, x_22, x_23, x_24); -if (lean_obj_tag(x_37) == 0) +x_38 = l_Lean_Meta_mkEq(x_36, x_37, x_21, x_22, x_23, x_24, x_25); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_89; uint8_t x_90; -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -x_39 = lean_ctor_get(x_37, 1); +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_91; uint8_t x_92; +x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -lean_dec(x_37); -x_89 = lean_unsigned_to_nat(0u); -x_90 = lean_nat_dec_lt(x_89, x_16); -if (x_90 == 0) +x_40 = lean_ctor_get(x_38, 1); +lean_inc(x_40); +lean_dec(x_38); +x_91 = lean_unsigned_to_nat(0u); +x_92 = lean_nat_dec_lt(x_91, x_17); +if (x_92 == 0) { -x_40 = x_38; x_41 = x_39; -goto block_88; +x_42 = x_40; +goto block_90; } else { -size_t x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; -x_91 = lean_usize_of_nat(x_16); -x_92 = l_Array_foldrMUnsafe_fold___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__4(x_17, x_91, x_18, x_38, x_20, x_21, x_22, x_23, x_39); -x_93 = lean_ctor_get(x_92, 0); -lean_inc(x_93); -x_94 = lean_ctor_get(x_92, 1); -lean_inc(x_94); -lean_dec(x_92); -x_40 = x_93; -x_41 = x_94; -goto block_88; +size_t x_93; lean_object* x_94; lean_object* x_95; lean_object* x_96; +x_93 = lean_usize_of_nat(x_17); +x_94 = l_Array_foldrMUnsafe_fold___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__4(x_18, x_93, x_19, x_39, x_21, x_22, x_23, x_24, x_40); +x_95 = lean_ctor_get(x_94, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_94, 1); +lean_inc(x_96); +lean_dec(x_94); +x_41 = x_95; +x_42 = x_96; +goto block_90; } -block_88: +block_90: { -lean_object* x_42; lean_object* x_43; uint8_t x_44; uint8_t x_45; uint8_t x_46; lean_object* x_47; -x_42 = l_Array_append___rarg(x_32, x_8); -x_43 = l_Array_append___rarg(x_42, x_19); -x_44 = 0; -x_45 = 1; +lean_object* x_43; lean_object* x_44; uint8_t x_45; uint8_t x_46; uint8_t x_47; lean_object* x_48; +x_43 = l_Array_append___rarg(x_33, x_8); +x_44 = l_Array_append___rarg(x_43, x_20); +x_45 = 0; x_46 = 1; -x_47 = l_Lean_Meta_mkForallFVars(x_43, x_40, x_44, x_45, x_46, x_20, x_21, x_22, x_23, x_41); -if (lean_obj_tag(x_47) == 0) +x_47 = 1; +x_48 = l_Lean_Meta_mkForallFVars(x_44, x_41, x_45, x_46, x_47, x_21, x_22, x_23, x_24, x_42); +if (lean_obj_tag(x_48) == 0) { -lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_48 = lean_ctor_get(x_47, 0); -lean_inc(x_48); -x_49 = lean_ctor_get(x_47, 1); +lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_49 = lean_ctor_get(x_48, 0); lean_inc(x_49); -lean_dec(x_47); -x_50 = l_Lean_Meta_Match_unfoldNamedPattern___closed__1; -x_51 = l_Lean_Meta_Match_unfoldNamedPattern___closed__2; +x_50 = lean_ctor_get(x_48, 1); +lean_inc(x_50); +lean_dec(x_48); +x_51 = l_Lean_Meta_Match_unfoldNamedPattern___closed__1; +x_52 = l_Lean_Meta_Match_unfoldNamedPattern___closed__2; +lean_inc(x_24); lean_inc(x_23); lean_inc(x_22); lean_inc(x_21); -lean_inc(x_20); -x_52 = l_Lean_Meta_transform___at_Lean_Meta_zetaReduce___spec__1(x_48, x_50, x_51, x_44, x_20, x_21, x_22, x_23, x_49); -if (lean_obj_tag(x_52) == 0) +x_53 = l_Lean_Meta_transform___at_Lean_Meta_zetaReduce___spec__1(x_49, x_51, x_52, x_45, x_21, x_22, x_23, x_24, x_50); +if (lean_obj_tag(x_53) == 0) { -lean_object* x_53; lean_object* x_54; lean_object* x_55; -x_53 = lean_ctor_get(x_52, 0); -lean_inc(x_53); -x_54 = lean_ctor_get(x_52, 1); +lean_object* x_54; lean_object* x_55; lean_object* x_56; +x_54 = lean_ctor_get(x_53, 0); lean_inc(x_54); -lean_dec(x_52); +x_55 = lean_ctor_get(x_53, 1); +lean_inc(x_55); +lean_dec(x_53); +lean_inc(x_24); lean_inc(x_23); lean_inc(x_22); lean_inc(x_21); -lean_inc(x_20); -lean_inc(x_53); -x_55 = l_Lean_Meta_Match_proveCondEqThm(x_9, x_53, x_20, x_21, x_22, x_23, x_54); -if (lean_obj_tag(x_55) == 0) +lean_inc(x_54); +x_56 = l_Lean_Meta_Match_proveCondEqThm(x_9, x_54, x_21, x_22, x_23, x_24, x_55); +if (lean_obj_tag(x_56) == 0) { -lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_56 = lean_ctor_get(x_55, 0); -lean_inc(x_56); -x_57 = lean_ctor_get(x_55, 1); +lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_57 = lean_ctor_get(x_56, 0); lean_inc(x_57); -lean_dec(x_55); -x_58 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_58, 0, x_10); -lean_ctor_set(x_58, 1, x_11); -lean_ctor_set(x_58, 2, x_53); -x_59 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_59, 0, x_58); -lean_ctor_set(x_59, 1, x_56); -x_60 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_60, 0, x_59); -x_61 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_60, x_20, x_21, x_22, x_23, x_57); -if (lean_obj_tag(x_61) == 0) +x_58 = lean_ctor_get(x_56, 1); +lean_inc(x_58); +lean_dec(x_56); +lean_inc(x_10); +x_59 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_59, 0, x_10); +lean_ctor_set(x_59, 1, x_11); +lean_ctor_set(x_59, 2, x_54); +x_60 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_60, 0, x_10); +lean_ctor_set(x_60, 1, x_12); +x_61 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_57); +lean_ctor_set(x_61, 2, x_60); +x_62 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_62, 0, x_61); +x_63 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_62, x_21, x_22, x_23, x_24, x_58); +if (lean_obj_tag(x_63) == 0) { -uint8_t x_62; -x_62 = !lean_is_exclusive(x_61); -if (x_62 == 0) +uint8_t x_64; +x_64 = !lean_is_exclusive(x_63); +if (x_64 == 0) { -lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; -x_63 = lean_ctor_get(x_61, 0); -lean_dec(x_63); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_12); -lean_ctor_set(x_64, 1, x_13); -x_65 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_65, 0, x_14); -lean_ctor_set(x_65, 1, x_64); +lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_65 = lean_ctor_get(x_63, 0); +lean_dec(x_65); x_66 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_66, 0, x_15); -lean_ctor_set(x_66, 1, x_65); -lean_ctor_set(x_61, 0, x_66); -return x_61; -} -else -{ -lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_67 = lean_ctor_get(x_61, 1); -lean_inc(x_67); -lean_dec(x_61); +lean_ctor_set(x_66, 0, x_13); +lean_ctor_set(x_66, 1, x_14); +x_67 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_67, 0, x_15); +lean_ctor_set(x_67, 1, x_66); x_68 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_68, 0, x_12); -lean_ctor_set(x_68, 1, x_13); -x_69 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_69, 0, x_14); -lean_ctor_set(x_69, 1, x_68); +lean_ctor_set(x_68, 0, x_16); +lean_ctor_set(x_68, 1, x_67); +lean_ctor_set(x_63, 0, x_68); +return x_63; +} +else +{ +lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_69 = lean_ctor_get(x_63, 1); +lean_inc(x_69); +lean_dec(x_63); x_70 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_70, 0, x_15); -lean_ctor_set(x_70, 1, x_69); +lean_ctor_set(x_70, 0, x_13); +lean_ctor_set(x_70, 1, x_14); x_71 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_71, 0, x_70); -lean_ctor_set(x_71, 1, x_67); -return x_71; +lean_ctor_set(x_71, 0, x_15); +lean_ctor_set(x_71, 1, x_70); +x_72 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_72, 0, x_16); +lean_ctor_set(x_72, 1, x_71); +x_73 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_73, 0, x_72); +lean_ctor_set(x_73, 1, x_69); +return x_73; } } else { -uint8_t x_72; +uint8_t x_74; +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +x_74 = !lean_is_exclusive(x_63); +if (x_74 == 0) +{ +return x_63; +} +else +{ +lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_75 = lean_ctor_get(x_63, 0); +x_76 = lean_ctor_get(x_63, 1); +lean_inc(x_76); +lean_inc(x_75); +lean_dec(x_63); +x_77 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set(x_77, 1, x_76); +return x_77; +} +} +} +else +{ +uint8_t x_78; +lean_dec(x_54); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_21); +lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); -x_72 = !lean_is_exclusive(x_61); -if (x_72 == 0) +lean_dec(x_11); +lean_dec(x_10); +x_78 = !lean_is_exclusive(x_56); +if (x_78 == 0) { -return x_61; +return x_56; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_61, 0); -x_74 = lean_ctor_get(x_61, 1); -lean_inc(x_74); -lean_inc(x_73); -lean_dec(x_61); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +lean_object* x_79; lean_object* x_80; lean_object* x_81; +x_79 = lean_ctor_get(x_56, 0); +x_80 = lean_ctor_get(x_56, 1); +lean_inc(x_80); +lean_inc(x_79); +lean_dec(x_56); +x_81 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_81, 0, x_79); +lean_ctor_set(x_81, 1, x_80); +return x_81; } } } else { -uint8_t x_76; +uint8_t x_82; +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_21); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +x_82 = !lean_is_exclusive(x_53); +if (x_82 == 0) +{ +return x_53; +} +else +{ +lean_object* x_83; lean_object* x_84; lean_object* x_85; +x_83 = lean_ctor_get(x_53, 0); +x_84 = lean_ctor_get(x_53, 1); +lean_inc(x_84); +lean_inc(x_83); lean_dec(x_53); -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_21); -lean_dec(x_20); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -x_76 = !lean_is_exclusive(x_55); -if (x_76 == 0) -{ -return x_55; -} -else -{ -lean_object* x_77; lean_object* x_78; lean_object* x_79; -x_77 = lean_ctor_get(x_55, 0); -x_78 = lean_ctor_get(x_55, 1); -lean_inc(x_78); -lean_inc(x_77); -lean_dec(x_55); -x_79 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_79, 0, x_77); -lean_ctor_set(x_79, 1, x_78); -return x_79; +x_85 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_85, 0, x_83); +lean_ctor_set(x_85, 1, x_84); +return x_85; } } } else { -uint8_t x_80; +uint8_t x_86; +lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); lean_dec(x_21); -lean_dec(x_20); +lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); @@ -31541,70 +31583,37 @@ lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); -x_80 = !lean_is_exclusive(x_52); -if (x_80 == 0) +x_86 = !lean_is_exclusive(x_48); +if (x_86 == 0) { -return x_52; +return x_48; } else { -lean_object* x_81; lean_object* x_82; lean_object* x_83; -x_81 = lean_ctor_get(x_52, 0); -x_82 = lean_ctor_get(x_52, 1); -lean_inc(x_82); -lean_inc(x_81); -lean_dec(x_52); -x_83 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_83, 0, x_81); -lean_ctor_set(x_83, 1, x_82); -return x_83; +lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_87 = lean_ctor_get(x_48, 0); +x_88 = lean_ctor_get(x_48, 1); +lean_inc(x_88); +lean_inc(x_87); +lean_dec(x_48); +x_89 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_89, 0, x_87); +lean_ctor_set(x_89, 1, x_88); +return x_89; +} } } } else { -uint8_t x_84; +uint8_t x_97; +lean_dec(x_33); +lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); lean_dec(x_21); lean_dec(x_20); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -x_84 = !lean_is_exclusive(x_47); -if (x_84 == 0) -{ -return x_47; -} -else -{ -lean_object* x_85; lean_object* x_86; lean_object* x_87; -x_85 = lean_ctor_get(x_47, 0); -x_86 = lean_ctor_get(x_47, 1); -lean_inc(x_86); -lean_inc(x_85); -lean_dec(x_47); -x_87 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_87, 0, x_85); -lean_ctor_set(x_87, 1, x_86); -return x_87; -} -} -} -} -else -{ -uint8_t x_95; -lean_dec(x_32); -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_21); -lean_dec(x_20); -lean_dec(x_19); +lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); @@ -31613,294 +31622,299 @@ lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); -x_95 = !lean_is_exclusive(x_37); -if (x_95 == 0) +x_97 = !lean_is_exclusive(x_38); +if (x_97 == 0) +{ +return x_38; +} +else +{ +lean_object* x_98; lean_object* x_99; lean_object* x_100; +x_98 = lean_ctor_get(x_38, 0); +x_99 = lean_ctor_get(x_38, 1); +lean_inc(x_99); +lean_inc(x_98); +lean_dec(x_38); +x_100 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_100, 0, x_98); +lean_ctor_set(x_100, 1, x_99); +return x_100; +} +} +} +} +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, size_t x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24, lean_object* x_25, lean_object* x_26, lean_object* x_27) { +_start: +{ +uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; +x_28 = 0; +x_29 = 1; +x_30 = 1; +x_31 = l_Lean_Meta_mkForallFVars(x_1, x_2, x_28, x_29, x_30, x_23, x_24, x_25, x_26, x_27); +if (lean_obj_tag(x_31) == 0) +{ +lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_78; uint8_t x_79; +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +lean_dec(x_31); +x_34 = lean_array_get_size(x_3); +x_78 = lean_unsigned_to_nat(0u); +x_79 = lean_nat_dec_lt(x_78, x_34); +if (x_79 == 0) +{ +x_35 = x_32; +x_36 = x_33; +goto block_77; +} +else +{ +size_t x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_80 = lean_usize_of_nat(x_34); +x_81 = l_Array_foldrMUnsafe_fold___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__4(x_3, x_80, x_8, x_32, x_23, x_24, x_25, x_26, x_33); +x_82 = lean_ctor_get(x_81, 0); +lean_inc(x_82); +x_83 = lean_ctor_get(x_81, 1); +lean_inc(x_83); +lean_dec(x_81); +x_35 = x_82; +x_36 = x_83; +goto block_77; +} +block_77: +{ +lean_object* x_37; +lean_inc(x_4); +x_37 = l_Lean_Meta_mkForallFVars(x_4, x_35, x_28, x_29, x_30, x_23, x_24, x_25, x_26, x_36); +if (lean_obj_tag(x_37) == 0) +{ +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; size_t x_52; lean_object* x_53; +x_38 = lean_ctor_get(x_37, 0); +lean_inc(x_38); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_40 = lean_array_get_size(x_4); +x_41 = lean_nat_add(x_34, x_40); +lean_dec(x_40); +x_42 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_simpH_x3f___closed__2; +x_43 = l_Lean_mkConst(x_42, x_5); +lean_inc(x_6); +x_44 = l_Array_reverse___rarg(x_6); +x_45 = lean_array_get_size(x_44); +x_46 = lean_unsigned_to_nat(0u); +x_47 = l_Array_toSubarray___rarg(x_44, x_46, x_45); +x_48 = l_Array_ofSubarray___rarg(x_7); +lean_inc(x_48); +x_49 = l_Array_reverse___rarg(x_48); +x_50 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_50, 0, x_47); +lean_ctor_set(x_50, 1, x_43); +x_51 = lean_array_get_size(x_49); +x_52 = lean_usize_of_nat(x_51); +lean_dec(x_51); +lean_inc(x_26); +lean_inc(x_25); +lean_inc(x_24); +lean_inc(x_23); +x_53 = l_Array_forInUnsafe_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__3(x_49, x_52, x_8, x_50, x_23, x_24, x_25, x_26, x_39); +lean_dec(x_49); +if (lean_obj_tag(x_53) == 0) +{ +lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; +x_54 = lean_ctor_get(x_53, 0); +lean_inc(x_54); +x_55 = lean_ctor_get(x_53, 1); +lean_inc(x_55); +lean_dec(x_53); +x_56 = lean_ctor_get(x_54, 1); +lean_inc(x_56); +lean_dec(x_54); +lean_inc(x_4); +lean_inc(x_48); +x_57 = l_Array_append___rarg(x_48, x_4); +x_58 = l_Lean_Meta_mkForallFVars(x_57, x_56, x_28, x_29, x_30, x_23, x_24, x_25, x_26, x_55); +if (lean_obj_tag(x_58) == 0) +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; +x_59 = lean_ctor_get(x_58, 0); +lean_inc(x_59); +x_60 = lean_ctor_get(x_58, 1); +lean_inc(x_60); +lean_dec(x_58); +x_61 = l_Array_ofSubarray___rarg(x_9); +x_62 = lean_box_usize(x_8); +lean_inc(x_6); +x_63 = lean_alloc_closure((void*)(l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1___boxed), 25, 19); +lean_closure_set(x_63, 0, x_10); +lean_closure_set(x_63, 1, x_11); +lean_closure_set(x_63, 2, x_12); +lean_closure_set(x_63, 3, x_13); +lean_closure_set(x_63, 4, x_14); +lean_closure_set(x_63, 5, x_6); +lean_closure_set(x_63, 6, x_15); +lean_closure_set(x_63, 7, x_4); +lean_closure_set(x_63, 8, x_16); +lean_closure_set(x_63, 9, x_17); +lean_closure_set(x_63, 10, x_18); +lean_closure_set(x_63, 11, x_19); +lean_closure_set(x_63, 12, x_41); +lean_closure_set(x_63, 13, x_20); +lean_closure_set(x_63, 14, x_38); +lean_closure_set(x_63, 15, x_59); +lean_closure_set(x_63, 16, x_34); +lean_closure_set(x_63, 17, x_3); +lean_closure_set(x_63, 18, x_62); +x_64 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_withNewAlts___rarg(x_21, x_48, x_6, x_61, x_63, x_23, x_24, x_25, x_26, x_60); +return x_64; +} +else +{ +uint8_t x_65; +lean_dec(x_48); +lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_34); +lean_dec(x_26); +lean_dec(x_25); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_20); +lean_dec(x_19); +lean_dec(x_18); +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_4); +lean_dec(x_3); +x_65 = !lean_is_exclusive(x_58); +if (x_65 == 0) +{ +return x_58; +} +else +{ +lean_object* x_66; lean_object* x_67; lean_object* x_68; +x_66 = lean_ctor_get(x_58, 0); +x_67 = lean_ctor_get(x_58, 1); +lean_inc(x_67); +lean_inc(x_66); +lean_dec(x_58); +x_68 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_68, 0, x_66); +lean_ctor_set(x_68, 1, x_67); +return x_68; +} +} +} +else +{ +uint8_t x_69; +lean_dec(x_48); +lean_dec(x_41); +lean_dec(x_38); +lean_dec(x_34); +lean_dec(x_26); +lean_dec(x_25); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_20); +lean_dec(x_19); +lean_dec(x_18); +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_6); +lean_dec(x_4); +lean_dec(x_3); +x_69 = !lean_is_exclusive(x_53); +if (x_69 == 0) +{ +return x_53; +} +else +{ +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_53, 0); +x_71 = lean_ctor_get(x_53, 1); +lean_inc(x_71); +lean_inc(x_70); +lean_dec(x_53); +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; +} +} +} +else +{ +uint8_t x_73; +lean_dec(x_34); +lean_dec(x_26); +lean_dec(x_25); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_20); +lean_dec(x_19); +lean_dec(x_18); +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_3); +x_73 = !lean_is_exclusive(x_37); +if (x_73 == 0) { return x_37; } else { -lean_object* x_96; lean_object* x_97; lean_object* x_98; -x_96 = lean_ctor_get(x_37, 0); -x_97 = lean_ctor_get(x_37, 1); -lean_inc(x_97); -lean_inc(x_96); -lean_dec(x_37); -x_98 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_98, 0, x_96); -lean_ctor_set(x_98, 1, x_97); -return x_98; -} -} -} -} -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, size_t x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24, lean_object* x_25, lean_object* x_26) { -_start: -{ -uint8_t x_27; uint8_t x_28; uint8_t x_29; lean_object* x_30; -x_27 = 0; -x_28 = 1; -x_29 = 1; -x_30 = l_Lean_Meta_mkForallFVars(x_1, x_2, x_27, x_28, x_29, x_22, x_23, x_24, x_25, x_26); -if (lean_obj_tag(x_30) == 0) -{ -lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_77; uint8_t x_78; -x_31 = lean_ctor_get(x_30, 0); -lean_inc(x_31); -x_32 = lean_ctor_get(x_30, 1); -lean_inc(x_32); -lean_dec(x_30); -x_33 = lean_array_get_size(x_3); -x_77 = lean_unsigned_to_nat(0u); -x_78 = lean_nat_dec_lt(x_77, x_33); -if (x_78 == 0) -{ -x_34 = x_31; -x_35 = x_32; -goto block_76; -} -else -{ -size_t x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; -x_79 = lean_usize_of_nat(x_33); -x_80 = l_Array_foldrMUnsafe_fold___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__4(x_3, x_79, x_8, x_31, x_22, x_23, x_24, x_25, x_32); -x_81 = lean_ctor_get(x_80, 0); -lean_inc(x_81); -x_82 = lean_ctor_get(x_80, 1); -lean_inc(x_82); -lean_dec(x_80); -x_34 = x_81; -x_35 = x_82; -goto block_76; -} -block_76: -{ -lean_object* x_36; -lean_inc(x_4); -x_36 = l_Lean_Meta_mkForallFVars(x_4, x_34, x_27, x_28, x_29, x_22, x_23, x_24, x_25, x_35); -if (lean_obj_tag(x_36) == 0) -{ -lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; size_t x_51; lean_object* x_52; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); -x_38 = lean_ctor_get(x_36, 1); -lean_inc(x_38); -lean_dec(x_36); -x_39 = lean_array_get_size(x_4); -x_40 = lean_nat_add(x_33, x_39); -lean_dec(x_39); -x_41 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_simpH_x3f___closed__2; -x_42 = l_Lean_mkConst(x_41, x_5); -lean_inc(x_6); -x_43 = l_Array_reverse___rarg(x_6); -x_44 = lean_array_get_size(x_43); -x_45 = lean_unsigned_to_nat(0u); -x_46 = l_Array_toSubarray___rarg(x_43, x_45, x_44); -x_47 = l_Array_ofSubarray___rarg(x_7); -lean_inc(x_47); -x_48 = l_Array_reverse___rarg(x_47); -x_49 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_49, 0, x_46); -lean_ctor_set(x_49, 1, x_42); -x_50 = lean_array_get_size(x_48); -x_51 = lean_usize_of_nat(x_50); -lean_dec(x_50); -lean_inc(x_25); -lean_inc(x_24); -lean_inc(x_23); -lean_inc(x_22); -x_52 = l_Array_forInUnsafe_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__3(x_48, x_51, x_8, x_49, x_22, x_23, x_24, x_25, x_38); -lean_dec(x_48); -if (lean_obj_tag(x_52) == 0) -{ -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; -x_53 = lean_ctor_get(x_52, 0); -lean_inc(x_53); -x_54 = lean_ctor_get(x_52, 1); -lean_inc(x_54); -lean_dec(x_52); -x_55 = lean_ctor_get(x_53, 1); -lean_inc(x_55); -lean_dec(x_53); -lean_inc(x_4); -lean_inc(x_47); -x_56 = l_Array_append___rarg(x_47, x_4); -x_57 = l_Lean_Meta_mkForallFVars(x_56, x_55, x_27, x_28, x_29, x_22, x_23, x_24, x_25, x_54); -if (lean_obj_tag(x_57) == 0) -{ -lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; -x_58 = lean_ctor_get(x_57, 0); -lean_inc(x_58); -x_59 = lean_ctor_get(x_57, 1); -lean_inc(x_59); -lean_dec(x_57); -x_60 = l_Array_ofSubarray___rarg(x_9); -x_61 = lean_box_usize(x_8); -lean_inc(x_6); -x_62 = lean_alloc_closure((void*)(l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1___boxed), 24, 18); -lean_closure_set(x_62, 0, x_10); -lean_closure_set(x_62, 1, x_11); -lean_closure_set(x_62, 2, x_12); -lean_closure_set(x_62, 3, x_13); -lean_closure_set(x_62, 4, x_14); -lean_closure_set(x_62, 5, x_6); -lean_closure_set(x_62, 6, x_15); -lean_closure_set(x_62, 7, x_4); -lean_closure_set(x_62, 8, x_16); -lean_closure_set(x_62, 9, x_17); -lean_closure_set(x_62, 10, x_18); -lean_closure_set(x_62, 11, x_40); -lean_closure_set(x_62, 12, x_19); -lean_closure_set(x_62, 13, x_37); -lean_closure_set(x_62, 14, x_58); -lean_closure_set(x_62, 15, x_33); -lean_closure_set(x_62, 16, x_3); -lean_closure_set(x_62, 17, x_61); -x_63 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_withNewAlts___rarg(x_20, x_47, x_6, x_60, x_62, x_22, x_23, x_24, x_25, x_59); -return x_63; -} -else -{ -uint8_t x_64; -lean_dec(x_47); -lean_dec(x_40); -lean_dec(x_37); -lean_dec(x_33); -lean_dec(x_25); -lean_dec(x_24); -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_19); -lean_dec(x_18); -lean_dec(x_17); -lean_dec(x_16); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_6); -lean_dec(x_4); -lean_dec(x_3); -x_64 = !lean_is_exclusive(x_57); -if (x_64 == 0) -{ -return x_57; -} -else -{ -lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_65 = lean_ctor_get(x_57, 0); -x_66 = lean_ctor_get(x_57, 1); -lean_inc(x_66); -lean_inc(x_65); -lean_dec(x_57); -x_67 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_67, 0, x_65); -lean_ctor_set(x_67, 1, x_66); -return x_67; -} -} -} -else -{ -uint8_t x_68; -lean_dec(x_47); -lean_dec(x_40); -lean_dec(x_37); -lean_dec(x_33); -lean_dec(x_25); -lean_dec(x_24); -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_19); -lean_dec(x_18); -lean_dec(x_17); -lean_dec(x_16); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_6); -lean_dec(x_4); -lean_dec(x_3); -x_68 = !lean_is_exclusive(x_52); -if (x_68 == 0) -{ -return x_52; -} -else -{ -lean_object* x_69; lean_object* x_70; lean_object* x_71; -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_52); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; -} -} -} -else -{ -uint8_t x_72; -lean_dec(x_33); -lean_dec(x_25); -lean_dec(x_24); -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_19); -lean_dec(x_18); -lean_dec(x_17); -lean_dec(x_16); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_3); -x_72 = !lean_is_exclusive(x_36); -if (x_72 == 0) -{ -return x_36; -} -else -{ -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_36, 0); -x_74 = lean_ctor_get(x_36, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_37, 0); +x_75 = lean_ctor_get(x_37, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); -lean_dec(x_36); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +lean_dec(x_37); +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } } else { -uint8_t x_83; +uint8_t x_84; +lean_dec(x_26); lean_dec(x_25); lean_dec(x_24); lean_dec(x_23); -lean_dec(x_22); +lean_dec(x_20); lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); @@ -31917,23 +31931,23 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_83 = !lean_is_exclusive(x_30); -if (x_83 == 0) +x_84 = !lean_is_exclusive(x_31); +if (x_84 == 0) { -return x_30; +return x_31; } else { -lean_object* x_84; lean_object* x_85; lean_object* x_86; -x_84 = lean_ctor_get(x_30, 0); -x_85 = lean_ctor_get(x_30, 1); +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_31, 0); +x_86 = lean_ctor_get(x_31, 1); +lean_inc(x_86); lean_inc(x_85); -lean_inc(x_84); -lean_dec(x_30); -x_86 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_86, 0, x_84); -lean_ctor_set(x_86, 1, x_85); -return x_86; +lean_dec(x_31); +x_87 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_87, 0, x_85); +lean_ctor_set(x_87, 1, x_86); +return x_87; } } } @@ -31955,121 +31969,122 @@ x_2 = l_Lean_stringToMessageData(x_1); return x_2; } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24, lean_object* x_25) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24, lean_object* x_25, lean_object* x_26) { _start: { -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; size_t x_34; size_t x_35; lean_object* x_36; -x_26 = lean_unsigned_to_nat(0u); -x_27 = l_Lean_Expr_getAppNumArgsAux(x_20, x_26); -x_28 = l_Lean_Meta_casesOnStuckLHS_findFVar_x3f___closed__1; -lean_inc(x_27); -x_29 = lean_mk_array(x_27, x_28); -x_30 = lean_unsigned_to_nat(1u); -x_31 = lean_nat_sub(x_27, x_30); -lean_dec(x_27); -lean_inc(x_20); -x_32 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_20, x_29, x_31); -x_33 = lean_array_get_size(x_1); -x_34 = lean_usize_of_nat(x_33); -lean_dec(x_33); -x_35 = 0; +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; size_t x_35; size_t x_36; lean_object* x_37; +x_27 = lean_unsigned_to_nat(0u); +x_28 = l_Lean_Expr_getAppNumArgsAux(x_21, x_27); +x_29 = l_Lean_Meta_casesOnStuckLHS_findFVar_x3f___closed__1; +lean_inc(x_28); +x_30 = lean_mk_array(x_28, x_29); +x_31 = lean_unsigned_to_nat(1u); +x_32 = lean_nat_sub(x_28, x_31); +lean_dec(x_28); +lean_inc(x_21); +x_33 = l___private_Lean_Expr_0__Lean_Expr_getAppArgsAux(x_21, x_30, x_32); +x_34 = lean_array_get_size(x_1); +x_35 = lean_usize_of_nat(x_34); +lean_dec(x_34); +x_36 = 0; +lean_inc(x_25); lean_inc(x_24); lean_inc(x_23); lean_inc(x_22); -lean_inc(x_21); -x_36 = l_Array_forInUnsafe_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__2(x_32, x_1, x_34, x_35, x_2, x_21, x_22, x_23, x_24, x_25); +x_37 = l_Array_forInUnsafe_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__2(x_33, x_1, x_35, x_36, x_2, x_22, x_23, x_24, x_25, x_26); lean_dec(x_1); -if (lean_obj_tag(x_36) == 0) +if (lean_obj_tag(x_37) == 0) { -lean_object* x_37; lean_object* x_38; uint8_t x_39; lean_object* x_40; lean_object* x_56; lean_object* x_57; lean_object* x_58; uint8_t x_59; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); -x_38 = lean_ctor_get(x_36, 1); +lean_object* x_38; lean_object* x_39; uint8_t x_40; lean_object* x_41; lean_object* x_57; lean_object* x_58; lean_object* x_59; uint8_t x_60; +x_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); -lean_dec(x_36); -x_56 = lean_st_ref_get(x_24, x_38); -x_57 = lean_ctor_get(x_56, 0); -lean_inc(x_57); -x_58 = lean_ctor_get(x_57, 3); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_57 = lean_st_ref_get(x_25, x_39); +x_58 = lean_ctor_get(x_57, 0); lean_inc(x_58); -lean_dec(x_57); -x_59 = lean_ctor_get_uint8(x_58, sizeof(void*)*1); +x_59 = lean_ctor_get(x_58, 3); +lean_inc(x_59); lean_dec(x_58); -if (x_59 == 0) +x_60 = lean_ctor_get_uint8(x_59, sizeof(void*)*1); +lean_dec(x_59); +if (x_60 == 0) { -lean_object* x_60; uint8_t x_61; -x_60 = lean_ctor_get(x_56, 1); -lean_inc(x_60); -lean_dec(x_56); -x_61 = 0; -x_39 = x_61; -x_40 = x_60; -goto block_55; +lean_object* x_61; uint8_t x_62; +x_61 = lean_ctor_get(x_57, 1); +lean_inc(x_61); +lean_dec(x_57); +x_62 = 0; +x_40 = x_62; +x_41 = x_61; +goto block_56; } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; uint8_t x_66; -x_62 = lean_ctor_get(x_56, 1); -lean_inc(x_62); -lean_dec(x_56); -lean_inc(x_15); -x_63 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_15, x_21, x_22, x_23, x_24, x_62); -x_64 = lean_ctor_get(x_63, 0); -lean_inc(x_64); -x_65 = lean_ctor_get(x_63, 1); +lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; +x_63 = lean_ctor_get(x_57, 1); +lean_inc(x_63); +lean_dec(x_57); +lean_inc(x_16); +x_64 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_16, x_22, x_23, x_24, x_25, x_63); +x_65 = lean_ctor_get(x_64, 0); lean_inc(x_65); -lean_dec(x_63); -x_66 = lean_unbox(x_64); +x_66 = lean_ctor_get(x_64, 1); +lean_inc(x_66); lean_dec(x_64); -x_39 = x_66; -x_40 = x_65; -goto block_55; +x_67 = lean_unbox(x_65); +lean_dec(x_65); +x_40 = x_67; +x_41 = x_66; +goto block_56; } -block_55: +block_56: { -if (x_39 == 0) +if (x_40 == 0) { -lean_object* x_41; lean_object* x_42; +lean_object* x_42; lean_object* x_43; +lean_dec(x_16); +x_42 = lean_box(0); +x_43 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(x_18, x_21, x_38, x_17, x_3, x_33, x_4, x_36, x_5, x_6, x_7, x_8, x_9, x_10, x_19, x_11, x_12, x_13, x_14, x_20, x_15, x_42, x_22, x_23, x_24, x_25, x_41); lean_dec(x_15); -x_41 = lean_box(0); -x_42 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(x_17, x_20, x_37, x_16, x_3, x_32, x_4, x_35, x_5, x_6, x_7, x_8, x_9, x_10, x_18, x_11, x_12, x_13, x_19, x_14, x_41, x_21, x_22, x_23, x_24, x_40); -lean_dec(x_14); -return x_42; +return x_43; } else { -lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; -lean_inc(x_37); -x_43 = lean_array_to_list(lean_box(0), x_37); -x_44 = lean_box(0); -x_45 = l_List_mapTRAux___at_Lean_MessageData_instCoeListExprMessageData___spec__1(x_43, x_44); -x_46 = l_Lean_MessageData_ofList(x_45); -lean_dec(x_45); -x_47 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3___closed__2; -x_48 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_48, 0, x_47); -lean_ctor_set(x_48, 1, x_46); -x_49 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__12; -x_50 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_50, 0, x_48); -lean_ctor_set(x_50, 1, x_49); -x_51 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_15, x_50, x_21, x_22, x_23, x_24, x_40); -x_52 = lean_ctor_get(x_51, 0); -lean_inc(x_52); -x_53 = lean_ctor_get(x_51, 1); +lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +lean_inc(x_38); +x_44 = lean_array_to_list(lean_box(0), x_38); +x_45 = lean_box(0); +x_46 = l_List_mapTRAux___at_Lean_MessageData_instCoeListExprMessageData___spec__1(x_44, x_45); +x_47 = l_Lean_MessageData_ofList(x_46); +lean_dec(x_46); +x_48 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3___closed__2; +x_49 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_49, 0, x_48); +lean_ctor_set(x_49, 1, x_47); +x_50 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__12; +x_51 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +x_52 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_16, x_51, x_22, x_23, x_24, x_25, x_41); +x_53 = lean_ctor_get(x_52, 0); lean_inc(x_53); -lean_dec(x_51); -x_54 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(x_17, x_20, x_37, x_16, x_3, x_32, x_4, x_35, x_5, x_6, x_7, x_8, x_9, x_10, x_18, x_11, x_12, x_13, x_19, x_14, x_52, x_21, x_22, x_23, x_24, x_53); +x_54 = lean_ctor_get(x_52, 1); +lean_inc(x_54); lean_dec(x_52); -lean_dec(x_14); -return x_54; +x_55 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(x_18, x_21, x_38, x_17, x_3, x_33, x_4, x_36, x_5, x_6, x_7, x_8, x_9, x_10, x_19, x_11, x_12, x_13, x_14, x_20, x_15, x_53, x_22, x_23, x_24, x_25, x_54); +lean_dec(x_53); +lean_dec(x_15); +return x_55; } } } else { -uint8_t x_67; -lean_dec(x_32); +uint8_t x_68; +lean_dec(x_33); +lean_dec(x_25); lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); @@ -32092,23 +32107,23 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_67 = !lean_is_exclusive(x_36); -if (x_67 == 0) +x_68 = !lean_is_exclusive(x_37); +if (x_68 == 0) { -return x_36; +return x_37; } else { -lean_object* x_68; lean_object* x_69; lean_object* x_70; -x_68 = lean_ctor_get(x_36, 0); -x_69 = lean_ctor_get(x_36, 1); +lean_object* x_69; lean_object* x_70; lean_object* x_71; +x_69 = lean_ctor_get(x_37, 0); +x_70 = lean_ctor_get(x_37, 1); +lean_inc(x_70); lean_inc(x_69); -lean_inc(x_68); -lean_dec(x_36); -x_70 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_70, 0, x_68); -lean_ctor_set(x_70, 1, x_69); -return x_70; +lean_dec(x_37); +x_71 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_71, 0, x_69); +lean_ctor_set(x_71, 1, x_70); +return x_71; } } } @@ -32177,121 +32192,120 @@ x_2 = l_Lean_stringToMessageData(x_1); return x_2; } } -LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24) { +LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21, lean_object* x_22, lean_object* x_23, lean_object* x_24, lean_object* x_25) { _start: { -uint8_t x_25; -x_25 = lean_nat_dec_le(x_17, x_16); -if (x_25 == 0) +uint8_t x_26; +x_26 = lean_nat_dec_le(x_18, x_17); +if (x_26 == 0) { -lean_object* x_26; uint8_t x_27; -x_26 = lean_unsigned_to_nat(0u); -x_27 = lean_nat_dec_eq(x_15, x_26); -if (x_27 == 0) +lean_object* x_27; uint8_t x_28; +x_27 = lean_unsigned_to_nat(0u); +x_28 = lean_nat_dec_eq(x_16, x_27); +if (x_28 == 0) { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; -x_28 = lean_unsigned_to_nat(1u); -x_29 = lean_nat_sub(x_15, x_28); -lean_dec(x_15); -x_30 = lean_ctor_get(x_19, 0); -lean_inc(x_30); -x_31 = lean_ctor_get(x_19, 1); +lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_29 = lean_unsigned_to_nat(1u); +x_30 = lean_nat_sub(x_16, x_29); +lean_dec(x_16); +x_31 = lean_ctor_get(x_20, 0); lean_inc(x_31); -lean_dec(x_19); -x_32 = lean_ctor_get(x_31, 0); +x_32 = lean_ctor_get(x_20, 1); lean_inc(x_32); -x_33 = lean_ctor_get(x_31, 1); +lean_dec(x_20); +x_33 = lean_ctor_get(x_32, 0); lean_inc(x_33); -lean_dec(x_31); -x_34 = lean_ctor_get(x_33, 0); +x_34 = lean_ctor_get(x_32, 1); lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_dec(x_32); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_35, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); -x_37 = lean_ctor_get(x_35, 1); +lean_dec(x_34); +x_37 = lean_ctor_get(x_36, 0); lean_inc(x_37); -lean_dec(x_35); -x_38 = lean_ctor_get(x_37, 0); +x_38 = lean_ctor_get(x_36, 1); lean_inc(x_38); -x_39 = lean_ctor_get(x_37, 1); +lean_dec(x_36); +x_39 = lean_ctor_get(x_38, 0); lean_inc(x_39); -lean_dec(x_37); -x_40 = lean_ctor_get(x_8, 2); -x_41 = l_instInhabitedNat; -x_42 = lean_array_get(x_41, x_40, x_16); -x_43 = lean_nat_sub(x_42, x_9); -lean_dec(x_42); -x_44 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___closed__2; -lean_inc(x_34); -x_45 = lean_name_append_index_after(x_44, x_34); -x_46 = l_Lean_Name_append(x_3, x_45); -lean_inc(x_46); -x_47 = lean_array_push(x_32, x_46); -x_48 = l_Lean_instInhabitedExpr; -x_49 = l_Subarray_get_x21___rarg(x_48, x_12, x_16); +x_40 = lean_ctor_get(x_38, 1); +lean_inc(x_40); +lean_dec(x_38); +x_41 = lean_ctor_get(x_8, 2); +x_42 = l_instInhabitedNat; +x_43 = lean_array_get(x_42, x_41, x_17); +x_44 = lean_nat_sub(x_43, x_9); +lean_dec(x_43); +x_45 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___closed__2; +lean_inc(x_35); +x_46 = lean_name_append_index_after(x_45, x_35); +x_47 = l_Lean_Name_append(x_3, x_46); +lean_inc(x_47); +x_48 = lean_array_push(x_33, x_47); +x_49 = l_Lean_instInhabitedExpr; +x_50 = l_Subarray_get_x21___rarg(x_49, x_13, x_17); +lean_inc(x_24); lean_inc(x_23); lean_inc(x_22); lean_inc(x_21); -lean_inc(x_20); -x_50 = lean_infer_type(x_49, x_20, x_21, x_22, x_23, x_24); -if (lean_obj_tag(x_50) == 0) +x_51 = lean_infer_type(x_50, x_21, x_22, x_23, x_24, x_25); +if (lean_obj_tag(x_51) == 0) { -lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; -x_51 = lean_ctor_get(x_50, 0); -lean_inc(x_51); -x_52 = lean_ctor_get(x_50, 1); +lean_object* x_52; lean_object* x_53; lean_object* x_54; lean_object* x_55; +x_52 = lean_ctor_get(x_51, 0); lean_inc(x_52); -lean_dec(x_50); +x_53 = lean_ctor_get(x_51, 1); +lean_inc(x_53); +lean_dec(x_51); lean_inc(x_2); lean_inc(x_9); +lean_inc(x_10); lean_inc(x_5); lean_inc(x_1); +lean_inc(x_12); lean_inc(x_11); -lean_inc(x_10); lean_inc(x_7); lean_inc(x_4); -lean_inc(x_16); -lean_inc(x_12); +lean_inc(x_17); lean_inc(x_13); -lean_inc(x_6); lean_inc(x_14); -lean_inc(x_36); -x_53 = lean_alloc_closure((void*)(l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3___boxed), 25, 15); -lean_closure_set(x_53, 0, x_36); -lean_closure_set(x_53, 1, x_14); -lean_closure_set(x_53, 2, x_6); -lean_closure_set(x_53, 3, x_13); -lean_closure_set(x_53, 4, x_12); -lean_closure_set(x_53, 5, x_16); -lean_closure_set(x_53, 6, x_4); -lean_closure_set(x_53, 7, x_7); -lean_closure_set(x_53, 8, x_10); -lean_closure_set(x_53, 9, x_11); -lean_closure_set(x_53, 10, x_1); -lean_closure_set(x_53, 11, x_46); -lean_closure_set(x_53, 12, x_5); -lean_closure_set(x_53, 13, x_9); -lean_closure_set(x_53, 14, x_2); +lean_inc(x_6); +lean_inc(x_15); +lean_inc(x_37); +x_54 = lean_alloc_closure((void*)(l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3___boxed), 26, 16); +lean_closure_set(x_54, 0, x_37); +lean_closure_set(x_54, 1, x_15); +lean_closure_set(x_54, 2, x_6); +lean_closure_set(x_54, 3, x_14); +lean_closure_set(x_54, 4, x_13); +lean_closure_set(x_54, 5, x_17); +lean_closure_set(x_54, 6, x_4); +lean_closure_set(x_54, 7, x_7); +lean_closure_set(x_54, 8, x_11); +lean_closure_set(x_54, 9, x_12); +lean_closure_set(x_54, 10, x_1); +lean_closure_set(x_54, 11, x_47); +lean_closure_set(x_54, 12, x_5); +lean_closure_set(x_54, 13, x_10); +lean_closure_set(x_54, 14, x_9); +lean_closure_set(x_54, 15, x_2); +lean_inc(x_24); lean_inc(x_23); lean_inc(x_22); lean_inc(x_21); -lean_inc(x_20); -x_54 = l_Lean_Meta_Match_forallAltTelescope___rarg(x_51, x_43, x_53, x_20, x_21, x_22, x_23, x_52); -if (lean_obj_tag(x_54) == 0) +x_55 = l_Lean_Meta_Match_forallAltTelescope___rarg(x_52, x_44, x_54, x_21, x_22, x_23, x_24, x_53); +if (lean_obj_tag(x_55) == 0) { -lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; uint8_t x_67; lean_object* x_68; lean_object* x_91; lean_object* x_92; lean_object* x_93; uint8_t x_94; -x_55 = lean_ctor_get(x_54, 0); -lean_inc(x_55); -x_56 = lean_ctor_get(x_55, 1); +lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; uint8_t x_68; lean_object* x_69; lean_object* x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; +x_56 = lean_ctor_get(x_55, 0); lean_inc(x_56); x_57 = lean_ctor_get(x_56, 1); lean_inc(x_57); -x_58 = lean_ctor_get(x_54, 1); +x_58 = lean_ctor_get(x_57, 1); lean_inc(x_58); -lean_dec(x_54); -x_59 = lean_ctor_get(x_55, 0); +x_59 = lean_ctor_get(x_55, 1); lean_inc(x_59); lean_dec(x_55); x_60 = lean_ctor_get(x_56, 0); @@ -32299,222 +32313,136 @@ lean_inc(x_60); lean_dec(x_56); x_61 = lean_ctor_get(x_57, 0); lean_inc(x_61); -x_62 = lean_ctor_get(x_57, 1); -lean_inc(x_62); lean_dec(x_57); -x_63 = lean_array_push(x_36, x_59); -lean_inc(x_60); -x_64 = lean_array_push(x_39, x_60); -x_65 = lean_array_push(x_38, x_61); -x_66 = lean_array_push(x_30, x_62); -x_91 = lean_st_ref_get(x_23, x_58); -x_92 = lean_ctor_get(x_91, 0); -lean_inc(x_92); -x_93 = lean_ctor_get(x_92, 3); +x_62 = lean_ctor_get(x_58, 0); +lean_inc(x_62); +x_63 = lean_ctor_get(x_58, 1); +lean_inc(x_63); +lean_dec(x_58); +x_64 = lean_array_push(x_37, x_60); +lean_inc(x_61); +x_65 = lean_array_push(x_40, x_61); +x_66 = lean_array_push(x_39, x_62); +x_67 = lean_array_push(x_31, x_63); +x_92 = lean_st_ref_get(x_24, x_59); +x_93 = lean_ctor_get(x_92, 0); lean_inc(x_93); -lean_dec(x_92); -x_94 = lean_ctor_get_uint8(x_93, sizeof(void*)*1); +x_94 = lean_ctor_get(x_93, 3); +lean_inc(x_94); lean_dec(x_93); -if (x_94 == 0) +x_95 = lean_ctor_get_uint8(x_94, sizeof(void*)*1); +lean_dec(x_94); +if (x_95 == 0) { -lean_object* x_95; uint8_t x_96; -x_95 = lean_ctor_get(x_91, 1); -lean_inc(x_95); -lean_dec(x_91); -x_96 = 0; -x_67 = x_96; -x_68 = x_95; -goto block_90; +lean_object* x_96; uint8_t x_97; +x_96 = lean_ctor_get(x_92, 1); +lean_inc(x_96); +lean_dec(x_92); +x_97 = 0; +x_68 = x_97; +x_69 = x_96; +goto block_91; } else { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; -x_97 = lean_ctor_get(x_91, 1); -lean_inc(x_97); -lean_dec(x_91); +lean_object* x_98; lean_object* x_99; lean_object* x_100; lean_object* x_101; uint8_t x_102; +x_98 = lean_ctor_get(x_92, 1); +lean_inc(x_98); +lean_dec(x_92); lean_inc(x_2); -x_98 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_2, x_20, x_21, x_22, x_23, x_97); -x_99 = lean_ctor_get(x_98, 0); -lean_inc(x_99); -x_100 = lean_ctor_get(x_98, 1); +x_99 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_2, x_21, x_22, x_23, x_24, x_98); +x_100 = lean_ctor_get(x_99, 0); lean_inc(x_100); -lean_dec(x_98); -x_101 = lean_unbox(x_99); +x_101 = lean_ctor_get(x_99, 1); +lean_inc(x_101); lean_dec(x_99); -x_67 = x_101; -x_68 = x_100; -goto block_90; +x_102 = lean_unbox(x_100); +lean_dec(x_100); +x_68 = x_102; +x_69 = x_101; +goto block_91; } -block_90: +block_91: { -if (x_67 == 0) +if (x_68 == 0) { -lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; -lean_dec(x_60); -x_69 = lean_box(0); -x_70 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__4(x_65, x_64, x_63, x_47, x_66, x_34, x_69, x_20, x_21, x_22, x_23, x_68); -lean_dec(x_34); -x_71 = lean_ctor_get(x_70, 0); -lean_inc(x_71); -x_72 = lean_ctor_get(x_70, 1); +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_dec(x_61); +x_70 = lean_box(0); +x_71 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__4(x_66, x_65, x_64, x_48, x_67, x_35, x_70, x_21, x_22, x_23, x_24, x_69); +lean_dec(x_35); +x_72 = lean_ctor_get(x_71, 0); lean_inc(x_72); -lean_dec(x_70); -x_73 = lean_ctor_get(x_71, 0); +x_73 = lean_ctor_get(x_71, 1); lean_inc(x_73); lean_dec(x_71); -x_74 = lean_nat_add(x_16, x_18); -lean_dec(x_16); -x_15 = x_29; -x_16 = x_74; -x_19 = x_73; -x_24 = x_72; +x_74 = lean_ctor_get(x_72, 0); +lean_inc(x_74); +lean_dec(x_72); +x_75 = lean_nat_add(x_17, x_19); +lean_dec(x_17); +x_16 = x_30; +x_17 = x_75; +x_20 = x_74; +x_25 = x_73; goto _start; } else { -lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; -x_76 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_76, 0, x_60); -x_77 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___closed__4; -x_78 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_78, 0, x_77); -lean_ctor_set(x_78, 1, x_76); -x_79 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__12; -x_80 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_80, 0, x_78); -lean_ctor_set(x_80, 1, x_79); +lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_77 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_77, 0, x_61); +x_78 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___closed__4; +x_79 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_79, 0, x_78); +lean_ctor_set(x_79, 1, x_77); +x_80 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__12; +x_81 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_81, 0, x_79); +lean_ctor_set(x_81, 1, x_80); lean_inc(x_2); -x_81 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_2, x_80, x_20, x_21, x_22, x_23, x_68); -x_82 = lean_ctor_get(x_81, 0); -lean_inc(x_82); -x_83 = lean_ctor_get(x_81, 1); +x_82 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_2, x_81, x_21, x_22, x_23, x_24, x_69); +x_83 = lean_ctor_get(x_82, 0); lean_inc(x_83); -lean_dec(x_81); -x_84 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__4(x_65, x_64, x_63, x_47, x_66, x_34, x_82, x_20, x_21, x_22, x_23, x_83); +x_84 = lean_ctor_get(x_82, 1); +lean_inc(x_84); lean_dec(x_82); -lean_dec(x_34); -x_85 = lean_ctor_get(x_84, 0); -lean_inc(x_85); -x_86 = lean_ctor_get(x_84, 1); +x_85 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__4(x_66, x_65, x_64, x_48, x_67, x_35, x_83, x_21, x_22, x_23, x_24, x_84); +lean_dec(x_83); +lean_dec(x_35); +x_86 = lean_ctor_get(x_85, 0); lean_inc(x_86); -lean_dec(x_84); -x_87 = lean_ctor_get(x_85, 0); +x_87 = lean_ctor_get(x_85, 1); lean_inc(x_87); lean_dec(x_85); -x_88 = lean_nat_add(x_16, x_18); -lean_dec(x_16); -x_15 = x_29; -x_16 = x_88; -x_19 = x_87; -x_24 = x_86; +x_88 = lean_ctor_get(x_86, 0); +lean_inc(x_88); +lean_dec(x_86); +x_89 = lean_nat_add(x_17, x_19); +lean_dec(x_17); +x_16 = x_30; +x_17 = x_89; +x_20 = x_88; +x_25 = x_87; goto _start; } } } else { -uint8_t x_102; -lean_dec(x_47); +uint8_t x_103; +lean_dec(x_48); +lean_dec(x_40); lean_dec(x_39); -lean_dec(x_38); -lean_dec(x_36); -lean_dec(x_34); +lean_dec(x_37); +lean_dec(x_35); +lean_dec(x_31); lean_dec(x_30); -lean_dec(x_29); +lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); lean_dec(x_21); -lean_dec(x_20); -lean_dec(x_16); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_102 = !lean_is_exclusive(x_54); -if (x_102 == 0) -{ -return x_54; -} -else -{ -lean_object* x_103; lean_object* x_104; lean_object* x_105; -x_103 = lean_ctor_get(x_54, 0); -x_104 = lean_ctor_get(x_54, 1); -lean_inc(x_104); -lean_inc(x_103); -lean_dec(x_54); -x_105 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_105, 0, x_103); -lean_ctor_set(x_105, 1, x_104); -return x_105; -} -} -} -else -{ -uint8_t x_106; -lean_dec(x_47); -lean_dec(x_46); -lean_dec(x_43); -lean_dec(x_39); -lean_dec(x_38); -lean_dec(x_36); -lean_dec(x_34); -lean_dec(x_30); -lean_dec(x_29); -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_21); -lean_dec(x_20); -lean_dec(x_16); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_106 = !lean_is_exclusive(x_50); -if (x_106 == 0) -{ -return x_50; -} -else -{ -lean_object* x_107; lean_object* x_108; lean_object* x_109; -x_107 = lean_ctor_get(x_50, 0); -x_108 = lean_ctor_get(x_50, 1); -lean_inc(x_108); -lean_inc(x_107); -lean_dec(x_50); -x_109 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_109, 0, x_107); -lean_ctor_set(x_109, 1, x_108); -return x_109; -} -} -} -else -{ -lean_object* x_110; -lean_dec(x_23); -lean_dec(x_22); -lean_dec(x_21); -lean_dec(x_20); -lean_dec(x_16); +lean_dec(x_17); lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); @@ -32528,19 +32456,84 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); -x_110 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_110, 0, x_19); -lean_ctor_set(x_110, 1, x_24); +x_103 = !lean_is_exclusive(x_55); +if (x_103 == 0) +{ +return x_55; +} +else +{ +lean_object* x_104; lean_object* x_105; lean_object* x_106; +x_104 = lean_ctor_get(x_55, 0); +x_105 = lean_ctor_get(x_55, 1); +lean_inc(x_105); +lean_inc(x_104); +lean_dec(x_55); +x_106 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_106, 0, x_104); +lean_ctor_set(x_106, 1, x_105); +return x_106; +} +} +} +else +{ +uint8_t x_107; +lean_dec(x_48); +lean_dec(x_47); +lean_dec(x_44); +lean_dec(x_40); +lean_dec(x_39); +lean_dec(x_37); +lean_dec(x_35); +lean_dec(x_31); +lean_dec(x_30); +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_21); +lean_dec(x_17); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_107 = !lean_is_exclusive(x_51); +if (x_107 == 0) +{ +return x_51; +} +else +{ +lean_object* x_108; lean_object* x_109; lean_object* x_110; +x_108 = lean_ctor_get(x_51, 0); +x_109 = lean_ctor_get(x_51, 1); +lean_inc(x_109); +lean_inc(x_108); +lean_dec(x_51); +x_110 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_110, 0, x_108); +lean_ctor_set(x_110, 1, x_109); return x_110; } } +} else { lean_object* x_111; +lean_dec(x_24); lean_dec(x_23); lean_dec(x_22); lean_dec(x_21); -lean_dec(x_20); +lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); @@ -32556,11 +32549,39 @@ lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); x_111 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_111, 0, x_19); -lean_ctor_set(x_111, 1, x_24); +lean_ctor_set(x_111, 0, x_20); +lean_ctor_set(x_111, 1, x_25); return x_111; } } +else +{ +lean_object* x_112; +lean_dec(x_24); +lean_dec(x_23); +lean_dec(x_22); +lean_dec(x_21); +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +lean_dec(x_10); +lean_dec(x_9); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_112 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_112, 0, x_20); +lean_ctor_set(x_112, 1, x_25); +return x_112; +} +} } LEAN_EXPORT lean_object* l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6) { _start: @@ -32628,258 +32649,266 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19) { +LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20) { _start: { -lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; -x_20 = l_Lean_ConstantInfo_name(x_1); -lean_inc(x_20); -x_21 = l_Lean_mkConst(x_20, x_2); -x_22 = l_Array_ofSubarray___rarg(x_3); -lean_inc(x_22); -x_23 = l_Array_append___rarg(x_4, x_22); -x_24 = l_Lean_mkAppN(x_21, x_23); -x_25 = lean_alloc_closure((void*)(l_Lean_Meta_Match_proveCondEqThm___lambda__1___boxed), 2, 1); -lean_closure_set(x_25, 0, x_20); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_21 = l_Lean_ConstantInfo_name(x_1); +lean_inc(x_21); +x_22 = l_Lean_mkConst(x_21, x_2); +x_23 = l_Array_ofSubarray___rarg(x_3); +lean_inc(x_23); +x_24 = l_Array_append___rarg(x_4, x_23); +x_25 = l_Lean_mkAppN(x_22, x_24); +x_26 = lean_alloc_closure((void*)(l_Lean_Meta_Match_proveCondEqThm___lambda__1___boxed), 2, 1); +lean_closure_set(x_26, 0, x_21); +lean_inc(x_19); lean_inc(x_18); -lean_inc(x_17); -x_26 = l_Lean_Meta_deltaExpand(x_24, x_25, x_17, x_18, x_19); -if (lean_obj_tag(x_26) == 0) +x_27 = l_Lean_Meta_deltaExpand(x_25, x_26, x_18, x_19, x_20); +if (lean_obj_tag(x_27) == 0) { -lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; -x_27 = lean_ctor_get(x_26, 0); -lean_inc(x_27); -x_28 = lean_ctor_get(x_26, 1); +lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_28 = lean_ctor_get(x_27, 0); lean_inc(x_28); -lean_dec(x_26); -x_29 = l_Lean_Expr_headBeta(x_27); +x_29 = lean_ctor_get(x_27, 1); +lean_inc(x_29); +lean_dec(x_27); +x_30 = l_Lean_Expr_headBeta(x_28); +lean_inc(x_19); lean_inc(x_18); lean_inc(x_17); lean_inc(x_16); -lean_inc(x_15); lean_inc(x_7); lean_inc(x_5); -x_30 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof(x_5, x_29, x_22, x_6, x_7, x_8, x_15, x_16, x_17, x_18, x_28); -if (lean_obj_tag(x_30) == 0) +x_31 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkSplitterProof(x_5, x_30, x_23, x_6, x_7, x_8, x_16, x_17, x_18, x_19, x_29); +if (lean_obj_tag(x_31) == 0) { -lean_object* x_31; lean_object* x_32; uint8_t x_33; uint8_t x_34; uint8_t x_35; lean_object* x_36; -x_31 = lean_ctor_get(x_30, 0); -lean_inc(x_31); -x_32 = lean_ctor_get(x_30, 1); +lean_object* x_32; lean_object* x_33; uint8_t x_34; uint8_t x_35; uint8_t x_36; lean_object* x_37; +x_32 = lean_ctor_get(x_31, 0); lean_inc(x_32); -lean_dec(x_30); -x_33 = 0; -x_34 = 1; +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +lean_dec(x_31); +x_34 = 0; x_35 = 1; -x_36 = l_Lean_Meta_mkLambdaFVars(x_9, x_31, x_33, x_34, x_35, x_15, x_16, x_17, x_18, x_32); -if (lean_obj_tag(x_36) == 0) +x_36 = 1; +x_37 = l_Lean_Meta_mkLambdaFVars(x_9, x_32, x_34, x_35, x_36, x_16, x_17, x_18, x_19, x_33); +if (lean_obj_tag(x_37) == 0) { -lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); -x_38 = lean_ctor_get(x_36, 1); +lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; +x_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); -lean_dec(x_36); -x_39 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1___closed__2; -x_40 = l_Lean_Name_append(x_10, x_39); -lean_inc(x_40); -x_41 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_41, 0, x_40); -lean_ctor_set(x_41, 1, x_11); -lean_ctor_set(x_41, 2, x_12); -x_42 = lean_box(1); -x_43 = 1; -x_44 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_44, 0, x_41); -lean_ctor_set(x_44, 1, x_37); -lean_ctor_set(x_44, 2, x_42); -lean_ctor_set_uint8(x_44, sizeof(void*)*3, x_43); -x_45 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_45, 0, x_44); +x_39 = lean_ctor_get(x_37, 1); +lean_inc(x_39); +lean_dec(x_37); +x_40 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1___closed__2; +x_41 = l_Lean_Name_append(x_10, x_40); +lean_inc(x_41); +x_42 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_42, 0, x_41); +lean_ctor_set(x_42, 1, x_11); +lean_ctor_set(x_42, 2, x_12); +lean_inc(x_41); +x_43 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_13); +x_44 = lean_box(1); +x_45 = 1; +x_46 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_46, 0, x_42); +lean_ctor_set(x_46, 1, x_38); +lean_ctor_set(x_46, 2, x_44); +lean_ctor_set(x_46, 3, x_43); +lean_ctor_set_uint8(x_46, sizeof(void*)*4, x_45); +x_47 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_47, 0, x_46); +lean_inc(x_19); lean_inc(x_18); lean_inc(x_17); lean_inc(x_16); -lean_inc(x_15); -x_46 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_45, x_15, x_16, x_17, x_18, x_38); -if (lean_obj_tag(x_46) == 0) +x_48 = l_Lean_addAndCompile___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__6(x_47, x_16, x_17, x_18, x_19, x_39); +if (lean_obj_tag(x_48) == 0) { -lean_object* x_47; uint8_t x_48; lean_object* x_49; -x_47 = lean_ctor_get(x_46, 1); -lean_inc(x_47); -lean_dec(x_46); -x_48 = 0; +lean_object* x_49; uint8_t x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_48, 1); +lean_inc(x_49); +lean_dec(x_48); +x_50 = 0; +lean_inc(x_19); lean_inc(x_18); -lean_inc(x_17); -lean_inc(x_40); -x_49 = l_Lean_Meta_setInlineAttribute(x_40, x_48, x_15, x_16, x_17, x_18, x_47); -if (lean_obj_tag(x_49) == 0) +lean_inc(x_41); +x_51 = l_Lean_Meta_setInlineAttribute(x_41, x_50, x_16, x_17, x_18, x_19, x_49); +if (lean_obj_tag(x_51) == 0) { -lean_object* x_50; lean_object* x_51; lean_object* x_52; uint8_t x_53; -x_50 = lean_ctor_get(x_49, 1); -lean_inc(x_50); -lean_dec(x_49); -x_51 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_51, 0, x_13); -lean_ctor_set(x_51, 1, x_40); -lean_ctor_set(x_51, 2, x_7); -lean_inc(x_51); -x_52 = l_Lean_Meta_Match_registerMatchEqns(x_5, x_51, x_17, x_18, x_50); +lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_52 = lean_ctor_get(x_51, 1); +lean_inc(x_52); +lean_dec(x_51); +x_53 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_53, 0, x_14); +lean_ctor_set(x_53, 1, x_41); +lean_ctor_set(x_53, 2, x_7); +lean_inc(x_53); +x_54 = l_Lean_Meta_Match_registerMatchEqns(x_5, x_53, x_18, x_19, x_52); +lean_dec(x_19); lean_dec(x_18); -lean_dec(x_17); -x_53 = !lean_is_exclusive(x_52); -if (x_53 == 0) +x_55 = !lean_is_exclusive(x_54); +if (x_55 == 0) { -lean_object* x_54; -x_54 = lean_ctor_get(x_52, 0); +lean_object* x_56; +x_56 = lean_ctor_get(x_54, 0); +lean_dec(x_56); +lean_ctor_set(x_54, 0, x_53); +return x_54; +} +else +{ +lean_object* x_57; lean_object* x_58; +x_57 = lean_ctor_get(x_54, 1); +lean_inc(x_57); lean_dec(x_54); -lean_ctor_set(x_52, 0, x_51); -return x_52; -} -else -{ -lean_object* x_55; lean_object* x_56; -x_55 = lean_ctor_get(x_52, 1); -lean_inc(x_55); -lean_dec(x_52); -x_56 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_56, 0, x_51); -lean_ctor_set(x_56, 1, x_55); -return x_56; +x_58 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_58, 0, x_53); +lean_ctor_set(x_58, 1, x_57); +return x_58; } } else { -uint8_t x_57; -lean_dec(x_40); +uint8_t x_59; +lean_dec(x_41); +lean_dec(x_19); lean_dec(x_18); -lean_dec(x_17); -lean_dec(x_13); +lean_dec(x_14); lean_dec(x_7); lean_dec(x_5); -x_57 = !lean_is_exclusive(x_49); -if (x_57 == 0) +x_59 = !lean_is_exclusive(x_51); +if (x_59 == 0) { -return x_49; +return x_51; } else { -lean_object* x_58; lean_object* x_59; lean_object* x_60; -x_58 = lean_ctor_get(x_49, 0); -x_59 = lean_ctor_get(x_49, 1); -lean_inc(x_59); -lean_inc(x_58); -lean_dec(x_49); -x_60 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_60, 0, x_58); -lean_ctor_set(x_60, 1, x_59); -return x_60; +lean_object* x_60; lean_object* x_61; lean_object* x_62; +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_51); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +return x_62; } } } else { -uint8_t x_61; -lean_dec(x_40); +uint8_t x_63; +lean_dec(x_41); +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); -lean_dec(x_13); +lean_dec(x_14); lean_dec(x_7); lean_dec(x_5); -x_61 = !lean_is_exclusive(x_46); -if (x_61 == 0) +x_63 = !lean_is_exclusive(x_48); +if (x_63 == 0) { -return x_46; +return x_48; } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; -x_62 = lean_ctor_get(x_46, 0); -x_63 = lean_ctor_get(x_46, 1); -lean_inc(x_63); -lean_inc(x_62); -lean_dec(x_46); -x_64 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_64, 0, x_62); -lean_ctor_set(x_64, 1, x_63); -return x_64; +lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_64 = lean_ctor_get(x_48, 0); +x_65 = lean_ctor_get(x_48, 1); +lean_inc(x_65); +lean_inc(x_64); +lean_dec(x_48); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_64); +lean_ctor_set(x_66, 1, x_65); +return x_66; } } } else { -uint8_t x_65; +uint8_t x_67; +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_7); lean_dec(x_5); -x_65 = !lean_is_exclusive(x_36); -if (x_65 == 0) +x_67 = !lean_is_exclusive(x_37); +if (x_67 == 0) { -return x_36; +return x_37; } else { -lean_object* x_66; lean_object* x_67; lean_object* x_68; -x_66 = lean_ctor_get(x_36, 0); -x_67 = lean_ctor_get(x_36, 1); -lean_inc(x_67); -lean_inc(x_66); -lean_dec(x_36); -x_68 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_68, 0, x_66); -lean_ctor_set(x_68, 1, x_67); -return x_68; +lean_object* x_68; lean_object* x_69; lean_object* x_70; +x_68 = lean_ctor_get(x_37, 0); +x_69 = lean_ctor_get(x_37, 1); +lean_inc(x_69); +lean_inc(x_68); +lean_dec(x_37); +x_70 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_70, 0, x_68); +lean_ctor_set(x_70, 1, x_69); +return x_70; } } } else { -uint8_t x_69; +uint8_t x_71; +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); lean_dec(x_9); lean_dec(x_7); lean_dec(x_5); -x_69 = !lean_is_exclusive(x_30); -if (x_69 == 0) +x_71 = !lean_is_exclusive(x_31); +if (x_71 == 0) { -return x_30; +return x_31; } else { -lean_object* x_70; lean_object* x_71; lean_object* x_72; -x_70 = lean_ctor_get(x_30, 0); -x_71 = lean_ctor_get(x_30, 1); -lean_inc(x_71); -lean_inc(x_70); -lean_dec(x_30); -x_72 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_72, 0, x_70); -lean_ctor_set(x_72, 1, x_71); -return x_72; +lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_72 = lean_ctor_get(x_31, 0); +x_73 = lean_ctor_get(x_31, 1); +lean_inc(x_73); +lean_inc(x_72); +lean_dec(x_31); +x_74 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_74, 0, x_72); +lean_ctor_set(x_74, 1, x_73); +return x_74; } } } else { -uint8_t x_73; -lean_dec(x_22); +uint8_t x_75; +lean_dec(x_23); +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); @@ -32888,23 +32917,23 @@ lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_73 = !lean_is_exclusive(x_26); -if (x_73 == 0) +x_75 = !lean_is_exclusive(x_27); +if (x_75 == 0) { -return x_26; +return x_27; } else { -lean_object* x_74; lean_object* x_75; lean_object* x_76; -x_74 = lean_ctor_get(x_26, 0); -x_75 = lean_ctor_get(x_26, 1); -lean_inc(x_75); -lean_inc(x_74); -lean_dec(x_26); -x_76 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_76, 0, x_74); -lean_ctor_set(x_76, 1, x_75); -return x_76; +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_27, 0); +x_77 = lean_ctor_get(x_27, 1); +lean_inc(x_77); +lean_inc(x_76); +lean_dec(x_27); +x_78 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_78, 0, x_76); +lean_ctor_set(x_78, 1, x_77); +return x_78; } } } @@ -32926,114 +32955,115 @@ x_2 = l_Lean_stringToMessageData(x_1); return x_2; } } -LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20) { +LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20, lean_object* x_21) { _start: { -lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; uint8_t x_28; uint8_t x_29; uint8_t x_30; lean_object* x_31; -x_21 = l_Array_ofSubarray___rarg(x_1); -x_22 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__6; -x_23 = lean_array_push(x_22, x_2); -x_24 = l_Array_append___rarg(x_21, x_23); -x_25 = l_Array_ofSubarray___rarg(x_3); -x_26 = l_Array_append___rarg(x_24, x_25); -lean_inc(x_15); -lean_inc(x_26); -x_27 = l_Array_append___rarg(x_26, x_15); -x_28 = 0; -x_29 = 1; -x_30 = 1; +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; uint8_t x_29; uint8_t x_30; uint8_t x_31; lean_object* x_32; +x_22 = l_Array_ofSubarray___rarg(x_1); +x_23 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__6; +x_24 = lean_array_push(x_23, x_2); +x_25 = l_Array_append___rarg(x_22, x_24); +x_26 = l_Array_ofSubarray___rarg(x_3); +x_27 = l_Array_append___rarg(x_25, x_26); +lean_inc(x_16); lean_inc(x_27); -x_31 = l_Lean_Meta_mkForallFVars(x_27, x_4, x_28, x_29, x_30, x_16, x_17, x_18, x_19, x_20); -if (lean_obj_tag(x_31) == 0) +x_28 = l_Array_append___rarg(x_27, x_16); +x_29 = 0; +x_30 = 1; +x_31 = 1; +lean_inc(x_28); +x_32 = l_Lean_Meta_mkForallFVars(x_28, x_4, x_29, x_30, x_31, x_17, x_18, x_19, x_20, x_21); +if (lean_obj_tag(x_32) == 0) { -lean_object* x_32; lean_object* x_33; uint8_t x_34; lean_object* x_35; lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; -x_32 = lean_ctor_get(x_31, 0); -lean_inc(x_32); -x_33 = lean_ctor_get(x_31, 1); +lean_object* x_33; lean_object* x_34; uint8_t x_35; lean_object* x_36; lean_object* x_49; lean_object* x_50; lean_object* x_51; uint8_t x_52; +x_33 = lean_ctor_get(x_32, 0); lean_inc(x_33); -lean_dec(x_31); -x_48 = lean_st_ref_get(x_19, x_33); -x_49 = lean_ctor_get(x_48, 0); -lean_inc(x_49); -x_50 = lean_ctor_get(x_49, 3); +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +lean_dec(x_32); +x_49 = lean_st_ref_get(x_20, x_34); +x_50 = lean_ctor_get(x_49, 0); lean_inc(x_50); -lean_dec(x_49); -x_51 = lean_ctor_get_uint8(x_50, sizeof(void*)*1); +x_51 = lean_ctor_get(x_50, 3); +lean_inc(x_51); lean_dec(x_50); -if (x_51 == 0) +x_52 = lean_ctor_get_uint8(x_51, sizeof(void*)*1); +lean_dec(x_51); +if (x_52 == 0) { -lean_object* x_52; -x_52 = lean_ctor_get(x_48, 1); -lean_inc(x_52); -lean_dec(x_48); -x_34 = x_28; -x_35 = x_52; -goto block_47; -} -else -{ -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_48, 1); +lean_object* x_53; +x_53 = lean_ctor_get(x_49, 1); lean_inc(x_53); -lean_dec(x_48); -lean_inc(x_14); -x_54 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_14, x_16, x_17, x_18, x_19, x_53); -x_55 = lean_ctor_get(x_54, 0); -lean_inc(x_55); -x_56 = lean_ctor_get(x_54, 1); +lean_dec(x_49); +x_35 = x_29; +x_36 = x_53; +goto block_48; +} +else +{ +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_49, 1); +lean_inc(x_54); +lean_dec(x_49); +lean_inc(x_15); +x_55 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_15, x_17, x_18, x_19, x_20, x_54); +x_56 = lean_ctor_get(x_55, 0); lean_inc(x_56); -lean_dec(x_54); -x_57 = lean_unbox(x_55); +x_57 = lean_ctor_get(x_55, 1); +lean_inc(x_57); lean_dec(x_55); -x_34 = x_57; -x_35 = x_56; -goto block_47; +x_58 = lean_unbox(x_56); +lean_dec(x_56); +x_35 = x_58; +x_36 = x_57; +goto block_48; } -block_47: +block_48: { -if (x_34 == 0) +if (x_35 == 0) { -lean_object* x_36; lean_object* x_37; -lean_dec(x_14); -x_36 = lean_box(0); -x_37 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(x_5, x_6, x_7, x_26, x_8, x_15, x_9, x_10, x_27, x_11, x_12, x_32, x_13, x_36, x_16, x_17, x_18, x_19, x_35); +lean_object* x_37; lean_object* x_38; +lean_dec(x_15); +x_37 = lean_box(0); +x_38 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(x_5, x_6, x_7, x_27, x_8, x_16, x_9, x_10, x_28, x_11, x_12, x_33, x_13, x_14, x_37, x_17, x_18, x_19, x_20, x_36); lean_dec(x_11); lean_dec(x_5); -return x_37; +return x_38; } else { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; -lean_inc(x_32); -x_38 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_38, 0, x_32); -x_39 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2___closed__2; -x_40 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_40, 0, x_39); -lean_ctor_set(x_40, 1, x_38); -x_41 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__12; -x_42 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_42, 0, x_40); -lean_ctor_set(x_42, 1, x_41); -x_43 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_14, x_42, x_16, x_17, x_18, x_19, x_35); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; +lean_inc(x_33); +x_39 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_39, 0, x_33); +x_40 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2___closed__2; +x_41 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_41, 0, x_40); +lean_ctor_set(x_41, 1, x_39); +x_42 = l_Lean_Meta_Match_forallAltTelescope_go___rarg___closed__12; +x_43 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_43, 0, x_41); +lean_ctor_set(x_43, 1, x_42); +x_44 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_15, x_43, x_17, x_18, x_19, x_20, x_36); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(x_5, x_6, x_7, x_26, x_8, x_15, x_9, x_10, x_27, x_11, x_12, x_32, x_13, x_44, x_16, x_17, x_18, x_19, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); lean_dec(x_44); +x_47 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(x_5, x_6, x_7, x_27, x_8, x_16, x_9, x_10, x_28, x_11, x_12, x_33, x_13, x_14, x_45, x_17, x_18, x_19, x_20, x_46); +lean_dec(x_45); lean_dec(x_11); lean_dec(x_5); -return x_46; +return x_47; } } } else { -uint8_t x_58; +uint8_t x_59; +lean_dec(x_28); lean_dec(x_27); -lean_dec(x_26); +lean_dec(x_20); lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); @@ -33049,23 +33079,23 @@ lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); -x_58 = !lean_is_exclusive(x_31); -if (x_58 == 0) +x_59 = !lean_is_exclusive(x_32); +if (x_59 == 0) { -return x_31; +return x_32; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_59 = lean_ctor_get(x_31, 0); -x_60 = lean_ctor_get(x_31, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; +x_60 = lean_ctor_get(x_32, 0); +x_61 = lean_ctor_get(x_32, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_31); -x_61 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_61, 0, x_59); -lean_ctor_set(x_61, 1, x_60); -return x_61; +lean_dec(x_32); +x_62 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_62, 0, x_60); +lean_ctor_set(x_62, 1, x_61); +return x_62; } } } @@ -33128,11 +33158,12 @@ lean_inc(x_27); lean_inc(x_22); lean_inc(x_20); lean_inc(x_9); +lean_inc_n(x_8, 2); lean_inc(x_7); lean_inc(x_6); lean_inc(x_4); lean_inc(x_3); -x_39 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_1, x_10, x_20, x_22, x_27, x_32, x_2, x_33, x_19, x_33, x_28, x_38, x_13, x_14, x_15, x_16, x_17); +x_39 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_1, x_10, x_8, x_20, x_22, x_27, x_32, x_2, x_33, x_19, x_33, x_28, x_38, x_13, x_14, x_15, x_16, x_17); lean_dec(x_33); lean_dec(x_1); if (lean_obj_tag(x_39) == 0) @@ -33164,7 +33195,7 @@ lean_inc(x_48); x_49 = lean_ctor_get(x_44, 1); lean_inc(x_49); lean_dec(x_44); -x_50 = lean_alloc_closure((void*)(l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2___boxed), 20, 14); +x_50 = lean_alloc_closure((void*)(l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2___boxed), 21, 15); lean_closure_set(x_50, 0, x_20); lean_closure_set(x_50, 1, x_22); lean_closure_set(x_50, 2, x_32); @@ -33177,8 +33208,9 @@ lean_closure_set(x_50, 8, x_48); lean_closure_set(x_50, 9, x_46); lean_closure_set(x_50, 10, x_5); lean_closure_set(x_50, 11, x_7); -lean_closure_set(x_50, 12, x_47); -lean_closure_set(x_50, 13, x_4); +lean_closure_set(x_50, 12, x_8); +lean_closure_set(x_50, 13, x_47); +lean_closure_set(x_50, 14, x_4); x_51 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_withSplitterAlts___rarg(x_49, x_50, x_13, x_14, x_15, x_16, x_45); return x_51; } @@ -33195,6 +33227,7 @@ lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_9); +lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); @@ -34111,17 +34144,18 @@ lean_object* x_21 = _args[20]; lean_object* x_22 = _args[21]; lean_object* x_23 = _args[22]; lean_object* x_24 = _args[23]; +lean_object* x_25 = _args[24]; _start: { -size_t x_25; lean_object* x_26; -x_25 = lean_unbox_usize(x_18); +size_t x_26; lean_object* x_27; +x_26 = lean_unbox_usize(x_19); +lean_dec(x_19); +x_27 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_26, x_20, x_21, x_22, x_23, x_24, x_25); lean_dec(x_18); -x_26 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_25, x_19, x_20, x_21, x_22, x_23, x_24); lean_dec(x_17); -lean_dec(x_16); lean_dec(x_2); lean_dec(x_1); -return x_26; +return x_27; } } LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2___boxed(lean_object** _args) { @@ -34151,15 +34185,16 @@ lean_object* x_23 = _args[22]; lean_object* x_24 = _args[23]; lean_object* x_25 = _args[24]; lean_object* x_26 = _args[25]; +lean_object* x_27 = _args[26]; _start: { -size_t x_27; lean_object* x_28; -x_27 = lean_unbox_usize(x_8); +size_t x_28; lean_object* x_29; +x_28 = lean_unbox_usize(x_8); lean_dec(x_8); -x_28 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_27, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21, x_22, x_23, x_24, x_25, x_26); +x_29 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_28, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21, x_22, x_23, x_24, x_25, x_26, x_27); +lean_dec(x_22); lean_dec(x_21); -lean_dec(x_20); -return x_28; +return x_29; } } LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3___boxed(lean_object** _args) { @@ -34188,11 +34223,12 @@ lean_object* x_22 = _args[21]; lean_object* x_23 = _args[22]; lean_object* x_24 = _args[23]; lean_object* x_25 = _args[24]; +lean_object* x_26 = _args[25]; _start: { -lean_object* x_26; -x_26 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21, x_22, x_23, x_24, x_25); -return x_26; +lean_object* x_27; +x_27 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21, x_22, x_23, x_24, x_25, x_26); +return x_27; } } LEAN_EXPORT lean_object* l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5___lambda__4___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { @@ -34234,15 +34270,16 @@ lean_object* x_21 = _args[20]; lean_object* x_22 = _args[21]; lean_object* x_23 = _args[22]; lean_object* x_24 = _args[23]; +lean_object* x_25 = _args[24]; _start: { -lean_object* x_25; -x_25 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21, x_22, x_23, x_24); +lean_object* x_26; +x_26 = l_Std_Range_forIn_loop___at___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___spec__5(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21, x_22, x_23, x_24, x_25); +lean_dec(x_19); lean_dec(x_18); -lean_dec(x_17); lean_dec(x_8); lean_dec(x_3); -return x_25; +return x_26; } } LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1___boxed(lean_object** _args) { @@ -34265,44 +34302,46 @@ lean_object* x_16 = _args[15]; lean_object* x_17 = _args[16]; lean_object* x_18 = _args[17]; lean_object* x_19 = _args[18]; -_start: -{ -lean_object* x_20; -x_20 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19); -lean_dec(x_14); -lean_dec(x_10); -lean_dec(x_1); -return x_20; -} -} -LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2___boxed(lean_object** _args) { -lean_object* x_1 = _args[0]; -lean_object* x_2 = _args[1]; -lean_object* x_3 = _args[2]; -lean_object* x_4 = _args[3]; -lean_object* x_5 = _args[4]; -lean_object* x_6 = _args[5]; -lean_object* x_7 = _args[6]; -lean_object* x_8 = _args[7]; -lean_object* x_9 = _args[8]; -lean_object* x_10 = _args[9]; -lean_object* x_11 = _args[10]; -lean_object* x_12 = _args[11]; -lean_object* x_13 = _args[12]; -lean_object* x_14 = _args[13]; -lean_object* x_15 = _args[14]; -lean_object* x_16 = _args[15]; -lean_object* x_17 = _args[16]; -lean_object* x_18 = _args[17]; -lean_object* x_19 = _args[18]; lean_object* x_20 = _args[19]; _start: { lean_object* x_21; -x_21 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20); +x_21 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20); +lean_dec(x_15); +lean_dec(x_10); +lean_dec(x_1); return x_21; } } +LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2___boxed(lean_object** _args) { +lean_object* x_1 = _args[0]; +lean_object* x_2 = _args[1]; +lean_object* x_3 = _args[2]; +lean_object* x_4 = _args[3]; +lean_object* x_5 = _args[4]; +lean_object* x_6 = _args[5]; +lean_object* x_7 = _args[6]; +lean_object* x_8 = _args[7]; +lean_object* x_9 = _args[8]; +lean_object* x_10 = _args[9]; +lean_object* x_11 = _args[10]; +lean_object* x_12 = _args[11]; +lean_object* x_13 = _args[12]; +lean_object* x_14 = _args[13]; +lean_object* x_15 = _args[14]; +lean_object* x_16 = _args[15]; +lean_object* x_17 = _args[16]; +lean_object* x_18 = _args[17]; +lean_object* x_19 = _args[18]; +lean_object* x_20 = _args[19]; +lean_object* x_21 = _args[20]; +_start: +{ +lean_object* x_22; +x_22 = l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__2(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20, x_21); +return x_22; +} +} LEAN_EXPORT lean_object* l___private_Lean_Meta_Match_MatchEqs_0__Lean_Meta_Match_mkEquationsFor___lambda__3___boxed(lean_object** _args) { lean_object* x_1 = _args[0]; lean_object* x_2 = _args[1]; diff --git a/stage0/stdlib/Lean/Meta/SizeOf.c b/stage0/stdlib/Lean/Meta/SizeOf.c index ae72370692..c117f8435c 100644 --- a/stage0/stdlib/Lean/Meta/SizeOf.c +++ b/stage0/stdlib/Lean/Meta/SizeOf.c @@ -43,10 +43,10 @@ lean_object* lean_array_uget(lean_object*, size_t); static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkLocalInstances_loop___rarg___closed__2; lean_object* l_Lean_Expr_bindingDomain_x21(lean_object*); lean_object* l_Array_append___rarg(lean_object*, lean_object*); -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Array_contains___at___private_Lean_Meta_SizeOf_0__Lean_Meta_isInductiveHypothesis_x3f___spec__1___boxed(lean_object*, lean_object*); static lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfFns___spec__3___closed__1; -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_ignoreField___closed__2; lean_object* l_Lean_Meta_mkAppM(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___closed__5; @@ -62,8 +62,8 @@ static lean_object* l_Lean_getConstInfo___at___private_Lean_Meta_SizeOf_0__Lean_ lean_object* l___private_Lean_Meta_Basic_0__Lean_Meta_withLocalDeclImp___rarg(lean_object*, uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_Meta_mkSizeOfFn___lambda__2___closed__2; static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___lambda__3___closed__2; -LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* lean_environment_find(lean_object*, lean_object*); lean_object* l_Lean_getConstInfo___at_Lean_Meta_mkConstWithFreshMVarLevels___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors_loop___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -115,7 +115,7 @@ LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkLocalInstan lean_object* l_List_head_x21___rarg(lean_object*, lean_object*); static lean_object* l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3___closed__3; uint8_t l___private_Lean_Message_0__Lean_beqMessageSeverity____x40_Lean_Message___hyg_101_(uint8_t, uint8_t); -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); uint8_t lean_usize_dec_lt(size_t, size_t); lean_object* l_Lean_Meta_whnfI(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_throwKernelException___at_Lean_Meta_mkSizeOfFn___spec__4___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -139,7 +139,7 @@ static lean_object* l_Lean_addTrace___at___private_Lean_Meta_SizeOf_0__Lean_Meta static lean_object* l_Lean_Meta_SizeOfSpecNested_throwFailed___rarg___closed__2; LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors(lean_object*); static lean_object* l_Lean_Meta_mkSizeOfSpecLemmaInstance___closed__4; -LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__3(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_mkAppN(lean_object*, lean_object*); LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Meta_mkSizeOfFns___spec__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors_loop___rarg___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -243,6 +243,7 @@ static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_r uint8_t l_Lean_Expr_isAppOfArity(lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkMinorProofStep___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_instInhabitedExpr; +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___lambda__2___closed__2; LEAN_EXPORT lean_object* l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___lambda__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -315,7 +316,7 @@ LEAN_EXPORT lean_object* l_Lean_throwKernelException___at_Lean_Meta_mkSizeOfFn__ static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___lambda__1___closed__3; static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors___rarg___closed__5; LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemmaProof___spec__5(lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__2(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkLocalInstances___rarg___closed__1; static lean_object* l_Lean_setEnv___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___spec__5___closed__1; static lean_object* l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3___closed__1; @@ -419,7 +420,7 @@ LEAN_EXPORT lean_object* l_Lean_throwError___at_Lean_Meta_SizeOfSpecNested_throw static lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__2___closed__1; LEAN_EXPORT lean_object* l_Lean_getConstInfoRec___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemmaProof___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors_loop___rarg___lambda__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); static lean_object* l_Lean_setEnv___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___spec__5___closed__11; LEAN_EXPORT lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors_loop___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorems(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -5646,66 +5647,71 @@ return x_23; } } } -LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { _start: { -uint8_t x_12; uint8_t x_13; uint8_t x_14; lean_object* x_15; -lean_dec(x_6); -x_12 = 0; -x_13 = 1; +uint8_t x_13; uint8_t x_14; uint8_t x_15; lean_object* x_16; +x_13 = 0; x_14 = 1; -x_15 = l_Lean_Meta_mkLambdaFVars(x_1, x_2, x_12, x_13, x_14, x_7, x_8, x_9, x_10, x_11); -if (lean_obj_tag(x_15) == 0) +x_15 = 1; +x_16 = l_Lean_Meta_mkLambdaFVars(x_1, x_2, x_13, x_14, x_15, x_8, x_9, x_10, x_11, x_12); +if (lean_obj_tag(x_16) == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; -x_16 = lean_ctor_get(x_15, 0); -lean_inc(x_16); -x_17 = lean_ctor_get(x_15, 1); +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; +x_17 = lean_ctor_get(x_16, 0); lean_inc(x_17); -lean_dec(x_15); -x_18 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_18, 0, x_3); -lean_ctor_set(x_18, 1, x_4); -lean_ctor_set(x_18, 2, x_5); -x_19 = lean_box(1); -x_20 = 1; -x_21 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_21, 0, x_18); -lean_ctor_set(x_21, 1, x_16); -lean_ctor_set(x_21, 2, x_19); -lean_ctor_set_uint8(x_21, sizeof(void*)*3, x_20); -x_22 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_22, 0, x_21); -x_23 = l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3(x_22, x_7, x_8, x_9, x_10, x_17); -return x_23; +x_18 = lean_ctor_get(x_16, 1); +lean_inc(x_18); +lean_dec(x_16); +lean_inc(x_3); +x_19 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_19, 0, x_3); +lean_ctor_set(x_19, 1, x_4); +lean_ctor_set(x_19, 2, x_5); +x_20 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_20, 0, x_3); +lean_ctor_set(x_20, 1, x_6); +x_21 = lean_box(1); +x_22 = 1; +x_23 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_23, 0, x_19); +lean_ctor_set(x_23, 1, x_17); +lean_ctor_set(x_23, 2, x_21); +lean_ctor_set(x_23, 3, x_20); +lean_ctor_set_uint8(x_23, sizeof(void*)*4, x_22); +x_24 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_24, 0, x_23); +x_25 = l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3(x_24, x_8, x_9, x_10, x_11, x_18); +return x_25; } else { -uint8_t x_24; +uint8_t x_26; +lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); lean_dec(x_8); -lean_dec(x_7); +lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_24 = !lean_is_exclusive(x_15); -if (x_24 == 0) +x_26 = !lean_is_exclusive(x_16); +if (x_26 == 0) { -return x_15; +return x_16; } else { -lean_object* x_25; lean_object* x_26; lean_object* x_27; -x_25 = lean_ctor_get(x_15, 0); -x_26 = lean_ctor_get(x_15, 1); -lean_inc(x_26); -lean_inc(x_25); -lean_dec(x_15); -x_27 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_27, 0, x_25); -lean_ctor_set(x_27, 1, x_26); -return x_27; +lean_object* x_27; lean_object* x_28; lean_object* x_29; +x_27 = lean_ctor_get(x_16, 0); +x_28 = lean_ctor_get(x_16, 1); +lean_inc(x_28); +lean_inc(x_27); +lean_dec(x_16); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_27); +lean_ctor_set(x_29, 1, x_28); +return x_29; } } } @@ -5727,112 +5733,114 @@ x_2 = l_Lean_stringToMessageData(x_1); return x_2; } } -LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15) { +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16) { _start: { -lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; uint8_t x_22; uint8_t x_23; uint8_t x_24; lean_object* x_25; -x_16 = l_Array_append___rarg(x_1, x_2); -x_17 = l_Array_ofSubarray___rarg(x_3); -lean_inc(x_17); -x_18 = l_Array_append___rarg(x_16, x_17); -x_19 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkLocalInstances_loop___rarg___lambda__1___closed__3; -x_20 = lean_array_push(x_19, x_4); -lean_inc(x_20); -x_21 = l_Array_append___rarg(x_18, x_20); -x_22 = 0; -x_23 = 1; -x_24 = 1; +lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; uint8_t x_23; uint8_t x_24; uint8_t x_25; lean_object* x_26; +x_17 = l_Array_append___rarg(x_1, x_2); +x_18 = l_Array_ofSubarray___rarg(x_3); +lean_inc(x_18); +x_19 = l_Array_append___rarg(x_17, x_18); +x_20 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkLocalInstances_loop___rarg___lambda__1___closed__3; +x_21 = lean_array_push(x_20, x_4); lean_inc(x_21); -x_25 = l_Lean_Meta_mkForallFVars(x_21, x_5, x_22, x_23, x_24, x_11, x_12, x_13, x_14, x_15); -if (lean_obj_tag(x_25) == 0) +x_22 = l_Array_append___rarg(x_19, x_21); +x_23 = 0; +x_24 = 1; +x_25 = 1; +lean_inc(x_22); +x_26 = l_Lean_Meta_mkForallFVars(x_22, x_5, x_23, x_24, x_25, x_12, x_13, x_14, x_15, x_16); +if (lean_obj_tag(x_26) == 0) { -lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; -x_26 = lean_ctor_get(x_25, 0); -lean_inc(x_26); -x_27 = lean_ctor_get(x_25, 1); +lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; +x_27 = lean_ctor_get(x_26, 0); lean_inc(x_27); -lean_dec(x_25); -x_28 = l_Array_append___rarg(x_10, x_17); -x_29 = l_Array_append___rarg(x_28, x_20); -x_30 = l_Lean_mkAppN(x_6, x_29); -x_45 = lean_st_ref_get(x_14, x_27); -x_46 = lean_ctor_get(x_45, 0); -lean_inc(x_46); -x_47 = lean_ctor_get(x_46, 3); +x_28 = lean_ctor_get(x_26, 1); +lean_inc(x_28); +lean_dec(x_26); +x_29 = l_Array_append___rarg(x_11, x_18); +x_30 = l_Array_append___rarg(x_29, x_21); +x_31 = l_Lean_mkAppN(x_6, x_30); +x_46 = lean_st_ref_get(x_15, x_28); +x_47 = lean_ctor_get(x_46, 0); lean_inc(x_47); -lean_dec(x_46); -x_48 = lean_ctor_get_uint8(x_47, sizeof(void*)*1); +x_48 = lean_ctor_get(x_47, 3); +lean_inc(x_48); lean_dec(x_47); -if (x_48 == 0) +x_49 = lean_ctor_get_uint8(x_48, sizeof(void*)*1); +lean_dec(x_48); +if (x_49 == 0) { -lean_object* x_49; -x_49 = lean_ctor_get(x_45, 1); -lean_inc(x_49); -lean_dec(x_45); -x_31 = x_22; -x_32 = x_49; -goto block_44; -} -else -{ -lean_object* x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; uint8_t x_54; -x_50 = lean_ctor_get(x_45, 1); +lean_object* x_50; +x_50 = lean_ctor_get(x_46, 1); lean_inc(x_50); -lean_dec(x_45); -lean_inc(x_9); -x_51 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_9, x_11, x_12, x_13, x_14, x_50); -x_52 = lean_ctor_get(x_51, 0); -lean_inc(x_52); -x_53 = lean_ctor_get(x_51, 1); +lean_dec(x_46); +x_32 = x_23; +x_33 = x_50; +goto block_45; +} +else +{ +lean_object* x_51; lean_object* x_52; lean_object* x_53; lean_object* x_54; uint8_t x_55; +x_51 = lean_ctor_get(x_46, 1); +lean_inc(x_51); +lean_dec(x_46); +lean_inc(x_10); +x_52 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_10, x_12, x_13, x_14, x_15, x_51); +x_53 = lean_ctor_get(x_52, 0); lean_inc(x_53); -lean_dec(x_51); -x_54 = lean_unbox(x_52); +x_54 = lean_ctor_get(x_52, 1); +lean_inc(x_54); lean_dec(x_52); -x_31 = x_54; -x_32 = x_53; -goto block_44; +x_55 = lean_unbox(x_53); +lean_dec(x_53); +x_32 = x_55; +x_33 = x_54; +goto block_45; } -block_44: +block_45: { -if (x_31 == 0) +if (x_32 == 0) { -lean_object* x_33; lean_object* x_34; -lean_dec(x_9); -x_33 = lean_box(0); -x_34 = l_Lean_Meta_mkSizeOfFn___lambda__1(x_21, x_30, x_7, x_8, x_26, x_33, x_11, x_12, x_13, x_14, x_32); -return x_34; +lean_object* x_34; lean_object* x_35; +lean_dec(x_10); +x_34 = lean_box(0); +x_35 = l_Lean_Meta_mkSizeOfFn___lambda__1(x_22, x_31, x_7, x_8, x_27, x_9, x_34, x_12, x_13, x_14, x_15, x_33); +return x_35; } else { -lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; -lean_inc(x_30); -x_35 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_35, 0, x_30); -x_36 = l_Lean_Meta_mkSizeOfFn___lambda__2___closed__2; -x_37 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_37, 0, x_36); -lean_ctor_set(x_37, 1, x_35); -x_38 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___closed__9; -x_39 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_39, 0, x_37); -lean_ctor_set(x_39, 1, x_38); -x_40 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_9, x_39, x_11, x_12, x_13, x_14, x_32); -x_41 = lean_ctor_get(x_40, 0); -lean_inc(x_41); -x_42 = lean_ctor_get(x_40, 1); +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_inc(x_31); +x_36 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_36, 0, x_31); +x_37 = l_Lean_Meta_mkSizeOfFn___lambda__2___closed__2; +x_38 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_38, 0, x_37); +lean_ctor_set(x_38, 1, x_36); +x_39 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___closed__9; +x_40 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_40, 0, x_38); +lean_ctor_set(x_40, 1, x_39); +x_41 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_10, x_40, x_12, x_13, x_14, x_15, x_33); +x_42 = lean_ctor_get(x_41, 0); lean_inc(x_42); -lean_dec(x_40); -x_43 = l_Lean_Meta_mkSizeOfFn___lambda__1(x_21, x_30, x_7, x_8, x_26, x_41, x_11, x_12, x_13, x_14, x_42); -return x_43; +x_43 = lean_ctor_get(x_41, 1); +lean_inc(x_43); +lean_dec(x_41); +x_44 = l_Lean_Meta_mkSizeOfFn___lambda__1(x_22, x_31, x_7, x_8, x_27, x_9, x_42, x_12, x_13, x_14, x_15, x_43); +lean_dec(x_42); +return x_44; } } } else { -uint8_t x_55; +uint8_t x_56; +lean_dec(x_22); lean_dec(x_21); -lean_dec(x_20); -lean_dec(x_17); +lean_dec(x_18); +lean_dec(x_15); lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); @@ -5842,50 +5850,52 @@ lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -x_55 = !lean_is_exclusive(x_25); -if (x_55 == 0) +x_56 = !lean_is_exclusive(x_26); +if (x_56 == 0) { -return x_25; +return x_26; } else { -lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_56 = lean_ctor_get(x_25, 0); -x_57 = lean_ctor_get(x_25, 1); +lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_57 = lean_ctor_get(x_26, 0); +x_58 = lean_ctor_get(x_26, 1); +lean_inc(x_58); lean_inc(x_57); -lean_inc(x_56); -lean_dec(x_25); -x_58 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_58, 0, x_56); -lean_ctor_set(x_58, 1, x_57); -return x_58; +lean_dec(x_26); +x_59 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_59, 0, x_57); +lean_ctor_set(x_59, 1, x_58); +return x_59; } } } } -LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18) { +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19) { _start: { -lean_object* x_19; lean_object* x_20; lean_object* x_21; -x_19 = l_Array_ofSubarray___rarg(x_1); -x_20 = lean_alloc_closure((void*)(l_Lean_Meta_mkSizeOfFn___lambda__2), 15, 9); -lean_closure_set(x_20, 0, x_2); -lean_closure_set(x_20, 1, x_3); -lean_closure_set(x_20, 2, x_4); -lean_closure_set(x_20, 3, x_5); -lean_closure_set(x_20, 4, x_6); -lean_closure_set(x_20, 5, x_7); -lean_closure_set(x_20, 6, x_8); -lean_closure_set(x_20, 7, x_9); -lean_closure_set(x_20, 8, x_10); -x_21 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors___rarg(x_11, x_19, x_12, x_20, x_14, x_15, x_16, x_17, x_18); -return x_21; +lean_object* x_20; lean_object* x_21; lean_object* x_22; +x_20 = l_Array_ofSubarray___rarg(x_1); +x_21 = lean_alloc_closure((void*)(l_Lean_Meta_mkSizeOfFn___lambda__2), 16, 10); +lean_closure_set(x_21, 0, x_2); +lean_closure_set(x_21, 1, x_3); +lean_closure_set(x_21, 2, x_4); +lean_closure_set(x_21, 3, x_5); +lean_closure_set(x_21, 4, x_6); +lean_closure_set(x_21, 5, x_7); +lean_closure_set(x_21, 6, x_8); +lean_closure_set(x_21, 7, x_9); +lean_closure_set(x_21, 8, x_10); +lean_closure_set(x_21, 9, x_11); +x_22 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMinors___rarg(x_12, x_20, x_13, x_21, x_15, x_16, x_17, x_18, x_19); +return x_22; } } LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__4(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19) { _start: { lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +lean_inc(x_2); lean_inc(x_1); x_20 = l_List_mapTRAux___at_Lean_mkConstWithLevelParams___spec__1(x_1, x_2); x_21 = l_Lean_levelOne; @@ -5912,7 +5922,7 @@ lean_inc(x_28); lean_dec(x_26); x_29 = lean_alloc_ctor(1, 1, 0); lean_ctor_set(x_29, 0, x_5); -x_30 = lean_alloc_closure((void*)(l_Lean_Meta_mkSizeOfFn___lambda__3___boxed), 18, 11); +x_30 = lean_alloc_closure((void*)(l_Lean_Meta_mkSizeOfFn___lambda__3___boxed), 19, 12); lean_closure_set(x_30, 0, x_6); lean_closure_set(x_30, 1, x_4); lean_closure_set(x_30, 2, x_7); @@ -5922,8 +5932,9 @@ lean_closure_set(x_30, 5, x_10); lean_closure_set(x_30, 6, x_25); lean_closure_set(x_30, 7, x_11); lean_closure_set(x_30, 8, x_1); -lean_closure_set(x_30, 9, x_12); -lean_closure_set(x_30, 10, x_13); +lean_closure_set(x_30, 9, x_2); +lean_closure_set(x_30, 10, x_12); +lean_closure_set(x_30, 11, x_13); x_31 = l_Lean_Meta_forallBoundedTelescope___at_Lean_Meta_addPPExplicitToExposeDiff_visit___spec__2___rarg(x_27, x_29, x_30, x_15, x_16, x_17, x_18, x_28); return x_31; } @@ -5945,6 +5956,7 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); +lean_dec(x_2); lean_dec(x_1); x_32 = !lean_is_exclusive(x_26); if (x_32 == 0) @@ -6264,6 +6276,15 @@ x_9 = l_Lean_log___at_Lean_Meta_mkSizeOfFn___spec__5(x_1, x_8, x_3, x_4, x_5, x_ return x_9; } } +LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +_start: +{ +lean_object* x_13; +x_13 = l_Lean_Meta_mkSizeOfFn___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12); +lean_dec(x_7); +return x_13; +} +} LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__3___boxed(lean_object** _args) { lean_object* x_1 = _args[0]; lean_object* x_2 = _args[1]; @@ -6283,12 +6304,13 @@ lean_object* x_15 = _args[14]; lean_object* x_16 = _args[15]; lean_object* x_17 = _args[16]; lean_object* x_18 = _args[17]; +lean_object* x_19 = _args[18]; _start: { -lean_object* x_19; -x_19 = l_Lean_Meta_mkSizeOfFn___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18); -lean_dec(x_13); -return x_19; +lean_object* x_20; +x_20 = l_Lean_Meta_mkSizeOfFn___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19); +lean_dec(x_14); +return x_20; } } LEAN_EXPORT lean_object* l_Lean_Meta_mkSizeOfFn___lambda__4___boxed(lean_object** _args) { @@ -11434,69 +11456,75 @@ return x_2; LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { _start: { -lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; +lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_inc(x_1); x_14 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_14, 0, x_1); lean_ctor_set(x_14, 1, x_2); lean_ctor_set(x_14, 2, x_3); -x_15 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_15, 0, x_14); -lean_ctor_set(x_15, 1, x_4); -x_16 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_16, 0, x_15); -x_17 = l_Lean_addDecl___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___spec__2(x_16, x_8, x_9, x_10, x_11, x_12, x_13); -if (lean_obj_tag(x_17) == 0) +x_15 = lean_box(0); +lean_inc(x_1); +x_16 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_16, 0, x_1); +lean_ctor_set(x_16, 1, x_15); +x_17 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_17, 0, x_14); +lean_ctor_set(x_17, 1, x_4); +lean_ctor_set(x_17, 2, x_16); +x_18 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_18, 0, x_17); +x_19 = l_Lean_addDecl___at___private_Lean_Meta_SizeOf_0__Lean_Meta_SizeOfSpecNested_mkSizeOfAuxLemma___spec__2(x_18, x_8, x_9, x_10, x_11, x_12, x_13); +if (lean_obj_tag(x_19) == 0) { -uint8_t x_18; -x_18 = !lean_is_exclusive(x_17); -if (x_18 == 0) +uint8_t x_20; +x_20 = !lean_is_exclusive(x_19); +if (x_20 == 0) { -lean_object* x_19; lean_object* x_20; lean_object* x_21; -x_19 = lean_ctor_get(x_17, 0); +lean_object* x_21; lean_object* x_22; lean_object* x_23; +x_21 = lean_ctor_get(x_19, 0); +lean_dec(x_21); +x_22 = l_Lean_mkConst(x_1, x_5); +x_23 = l_Lean_mkAppN(x_22, x_6); +lean_ctor_set(x_19, 0, x_23); +return x_19; +} +else +{ +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; +x_24 = lean_ctor_get(x_19, 1); +lean_inc(x_24); lean_dec(x_19); -x_20 = l_Lean_mkConst(x_1, x_5); -x_21 = l_Lean_mkAppN(x_20, x_6); -lean_ctor_set(x_17, 0, x_21); -return x_17; -} -else -{ -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_22 = lean_ctor_get(x_17, 1); -lean_inc(x_22); -lean_dec(x_17); -x_23 = l_Lean_mkConst(x_1, x_5); -x_24 = l_Lean_mkAppN(x_23, x_6); -x_25 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_25, 0, x_24); -lean_ctor_set(x_25, 1, x_22); -return x_25; +x_25 = l_Lean_mkConst(x_1, x_5); +x_26 = l_Lean_mkAppN(x_25, x_6); +x_27 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_27, 0, x_26); +lean_ctor_set(x_27, 1, x_24); +return x_27; } } else { -uint8_t x_26; +uint8_t x_28; lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_26 = !lean_is_exclusive(x_17); -if (x_26 == 0) +x_28 = !lean_is_exclusive(x_19); +if (x_28 == 0) { -return x_17; +return x_19; } else { -lean_object* x_27; lean_object* x_28; lean_object* x_29; -x_27 = lean_ctor_get(x_17, 0); -x_28 = lean_ctor_get(x_17, 1); -lean_inc(x_28); -lean_inc(x_27); -lean_dec(x_17); -x_29 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_29, 0, x_27); -lean_ctor_set(x_29, 1, x_28); -return x_29; +lean_object* x_29; lean_object* x_30; lean_object* x_31; +x_29 = lean_ctor_get(x_19, 0); +x_30 = lean_ctor_get(x_19, 1); +lean_inc(x_30); +lean_inc(x_29); +lean_dec(x_19); +x_31 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_31, 0, x_29); +lean_ctor_set(x_31, 1, x_30); +return x_31; } } } @@ -15658,62 +15686,67 @@ return x_45; } } } -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { _start: { -lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; +lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_inc(x_1); -x_12 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_12, 0, x_1); -lean_ctor_set(x_12, 1, x_2); -lean_ctor_set(x_12, 2, x_3); -x_13 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_13, 0, x_12); -lean_ctor_set(x_13, 1, x_4); -x_14 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_14, 0, x_13); +x_13 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_13, 0, x_1); +lean_ctor_set(x_13, 1, x_2); +lean_ctor_set(x_13, 2, x_3); +lean_inc(x_1); +x_14 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_14, 0, x_1); +lean_ctor_set(x_14, 1, x_4); +x_15 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_15, 0, x_13); +lean_ctor_set(x_15, 1, x_5); +lean_ctor_set(x_15, 2, x_14); +x_16 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_16, 0, x_15); +lean_inc(x_11); lean_inc(x_10); -lean_inc(x_9); -x_15 = l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3(x_14, x_7, x_8, x_9, x_10, x_11); -if (lean_obj_tag(x_15) == 0) +x_17 = l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3(x_16, x_8, x_9, x_10, x_11, x_12); +if (lean_obj_tag(x_17) == 0) { -lean_object* x_16; lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_21; -x_16 = lean_ctor_get(x_15, 1); -lean_inc(x_16); -lean_dec(x_15); -x_17 = lean_ctor_get(x_5, 1); -lean_inc(x_17); -lean_dec(x_5); -x_18 = lean_box(0); -x_19 = 0; -x_20 = lean_box(x_19); -x_21 = lean_apply_6(x_17, x_1, x_18, x_20, x_9, x_10, x_16); -return x_21; +lean_object* x_18; lean_object* x_19; lean_object* x_20; uint8_t x_21; lean_object* x_22; lean_object* x_23; +x_18 = lean_ctor_get(x_17, 1); +lean_inc(x_18); +lean_dec(x_17); +x_19 = lean_ctor_get(x_6, 1); +lean_inc(x_19); +lean_dec(x_6); +x_20 = lean_box(0); +x_21 = 0; +x_22 = lean_box(x_21); +x_23 = lean_apply_6(x_19, x_1, x_20, x_22, x_10, x_11, x_18); +return x_23; } else { -uint8_t x_22; +uint8_t x_24; +lean_dec(x_11); lean_dec(x_10); -lean_dec(x_9); -lean_dec(x_5); +lean_dec(x_6); lean_dec(x_1); -x_22 = !lean_is_exclusive(x_15); -if (x_22 == 0) +x_24 = !lean_is_exclusive(x_17); +if (x_24 == 0) { -return x_15; +return x_17; } else { -lean_object* x_23; lean_object* x_24; lean_object* x_25; -x_23 = lean_ctor_get(x_15, 0); -x_24 = lean_ctor_get(x_15, 1); -lean_inc(x_24); -lean_inc(x_23); -lean_dec(x_15); -x_25 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_25, 0, x_23); -lean_ctor_set(x_25, 1, x_24); -return x_25; +lean_object* x_25; lean_object* x_26; lean_object* x_27; +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_27 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_27, 0, x_25); +lean_ctor_set(x_27, 1, x_26); +return x_27; } } } @@ -15735,285 +15768,289 @@ x_2 = l_Lean_stringToMessageData(x_1); return x_2; } } -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13) { _start: { -uint8_t x_13; uint8_t x_14; uint8_t x_15; lean_object* x_16; -x_13 = 0; -x_14 = 1; +uint8_t x_14; uint8_t x_15; uint8_t x_16; lean_object* x_17; +x_14 = 0; x_15 = 1; -x_16 = l_Lean_Meta_mkLambdaFVars(x_1, x_7, x_13, x_14, x_15, x_8, x_9, x_10, x_11, x_12); -if (lean_obj_tag(x_16) == 0) +x_16 = 1; +x_17 = l_Lean_Meta_mkLambdaFVars(x_1, x_8, x_14, x_15, x_16, x_9, x_10, x_11, x_12, x_13); +if (lean_obj_tag(x_17) == 0) { -lean_object* x_17; lean_object* x_18; uint8_t x_19; lean_object* x_20; lean_object* x_33; lean_object* x_34; lean_object* x_35; uint8_t x_36; -x_17 = lean_ctor_get(x_16, 0); -lean_inc(x_17); -x_18 = lean_ctor_get(x_16, 1); +lean_object* x_18; lean_object* x_19; uint8_t x_20; lean_object* x_21; lean_object* x_34; lean_object* x_35; lean_object* x_36; uint8_t x_37; +x_18 = lean_ctor_get(x_17, 0); lean_inc(x_18); -lean_dec(x_16); -x_33 = lean_st_ref_get(x_11, x_18); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_34, 3); +x_19 = lean_ctor_get(x_17, 1); +lean_inc(x_19); +lean_dec(x_17); +x_34 = lean_st_ref_get(x_12, x_19); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_34); -x_36 = lean_ctor_get_uint8(x_35, sizeof(void*)*1); +x_36 = lean_ctor_get(x_35, 3); +lean_inc(x_36); lean_dec(x_35); -if (x_36 == 0) +x_37 = lean_ctor_get_uint8(x_36, sizeof(void*)*1); +lean_dec(x_36); +if (x_37 == 0) { -lean_object* x_37; -x_37 = lean_ctor_get(x_33, 1); -lean_inc(x_37); -lean_dec(x_33); -x_19 = x_13; -x_20 = x_37; -goto block_32; -} -else -{ -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; uint8_t x_42; -x_38 = lean_ctor_get(x_33, 1); +lean_object* x_38; +x_38 = lean_ctor_get(x_34, 1); lean_inc(x_38); -lean_dec(x_33); -lean_inc(x_6); -x_39 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_6, x_8, x_9, x_10, x_11, x_38); -x_40 = lean_ctor_get(x_39, 0); -lean_inc(x_40); -x_41 = lean_ctor_get(x_39, 1); +lean_dec(x_34); +x_20 = x_14; +x_21 = x_38; +goto block_33; +} +else +{ +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; uint8_t x_43; +x_39 = lean_ctor_get(x_34, 1); +lean_inc(x_39); +lean_dec(x_34); +lean_inc(x_7); +x_40 = l___private_Lean_Util_Trace_0__Lean_checkTraceOptionM___at___private_Lean_Meta_Basic_0__Lean_Meta_processPostponedStep___spec__14(x_7, x_9, x_10, x_11, x_12, x_39); +x_41 = lean_ctor_get(x_40, 0); lean_inc(x_41); -lean_dec(x_39); -x_42 = lean_unbox(x_40); +x_42 = lean_ctor_get(x_40, 1); +lean_inc(x_42); lean_dec(x_40); -x_19 = x_42; -x_20 = x_41; -goto block_32; +x_43 = lean_unbox(x_41); +lean_dec(x_41); +x_20 = x_43; +x_21 = x_42; +goto block_33; } -block_32: +block_33: { -if (x_19 == 0) +if (x_20 == 0) { -lean_object* x_21; lean_object* x_22; -lean_dec(x_6); -x_21 = lean_box(0); -x_22 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(x_2, x_3, x_4, x_17, x_5, x_21, x_8, x_9, x_10, x_11, x_20); -return x_22; +lean_object* x_22; lean_object* x_23; +lean_dec(x_7); +x_22 = lean_box(0); +x_23 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(x_2, x_3, x_4, x_5, x_18, x_6, x_22, x_9, x_10, x_11, x_12, x_21); +return x_23; } else { -lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; +lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_inc(x_2); -x_23 = lean_alloc_ctor(4, 1, 0); -lean_ctor_set(x_23, 0, x_2); -x_24 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2___closed__2; -x_25 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_25, 0, x_24); -lean_ctor_set(x_25, 1, x_23); -x_26 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___closed__9; -x_27 = lean_alloc_ctor(10, 2, 0); -lean_ctor_set(x_27, 0, x_25); -lean_ctor_set(x_27, 1, x_26); -x_28 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_6, x_27, x_8, x_9, x_10, x_11, x_20); -x_29 = lean_ctor_get(x_28, 0); -lean_inc(x_29); -x_30 = lean_ctor_get(x_28, 1); +x_24 = lean_alloc_ctor(4, 1, 0); +lean_ctor_set(x_24, 0, x_2); +x_25 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2___closed__2; +x_26 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_26, 0, x_25); +lean_ctor_set(x_26, 1, x_24); +x_27 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___closed__9; +x_28 = lean_alloc_ctor(10, 2, 0); +lean_ctor_set(x_28, 0, x_26); +lean_ctor_set(x_28, 1, x_27); +x_29 = l_Lean_addTrace___at_Lean_Meta_processPostponed_loop___spec__1(x_7, x_28, x_9, x_10, x_11, x_12, x_21); +x_30 = lean_ctor_get(x_29, 0); lean_inc(x_30); -lean_dec(x_28); -x_31 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(x_2, x_3, x_4, x_17, x_5, x_29, x_8, x_9, x_10, x_11, x_30); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); lean_dec(x_29); -return x_31; +x_32 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(x_2, x_3, x_4, x_5, x_18, x_6, x_30, x_9, x_10, x_11, x_12, x_31); +lean_dec(x_30); +return x_32; } } } else { -uint8_t x_43; +uint8_t x_44; +lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); -lean_dec(x_8); +lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); lean_dec(x_2); -x_43 = !lean_is_exclusive(x_16); -if (x_43 == 0) +x_44 = !lean_is_exclusive(x_17); +if (x_44 == 0) { -return x_16; +return x_17; } else { -lean_object* x_44; lean_object* x_45; lean_object* x_46; -x_44 = lean_ctor_get(x_16, 0); -x_45 = lean_ctor_get(x_16, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_17, 0); +x_46 = lean_ctor_get(x_17, 1); +lean_inc(x_46); lean_inc(x_45); -lean_inc(x_44); -lean_dec(x_16); -x_46 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_46, 0, x_44); -lean_ctor_set(x_46, 1, x_45); -return x_46; +lean_dec(x_17); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; } } } } -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19) { +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18, lean_object* x_19, lean_object* x_20) { _start: { -lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; uint8_t x_24; uint8_t x_25; uint8_t x_26; lean_object* x_27; -x_20 = l_Lean_Meta_mkSizeOfSpecLemmaName(x_1); +lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; +x_21 = l_Lean_Meta_mkSizeOfSpecLemmaName(x_1); lean_inc(x_3); lean_inc(x_2); -x_21 = l_Array_append___rarg(x_2, x_3); -x_22 = l_Array_ofSubarray___rarg(x_4); -x_23 = l_Array_append___rarg(x_21, x_22); -x_24 = 0; -x_25 = 1; +x_22 = l_Array_append___rarg(x_2, x_3); +x_23 = l_Array_ofSubarray___rarg(x_4); +x_24 = l_Array_append___rarg(x_22, x_23); +x_25 = 0; x_26 = 1; -lean_inc(x_23); -x_27 = l_Lean_Meta_mkForallFVars(x_23, x_5, x_24, x_25, x_26, x_15, x_16, x_17, x_18, x_19); -if (lean_obj_tag(x_27) == 0) +x_27 = 1; +lean_inc(x_24); +x_28 = l_Lean_Meta_mkForallFVars(x_24, x_5, x_25, x_26, x_27, x_16, x_17, x_18, x_19, x_20); +if (lean_obj_tag(x_28) == 0) { -uint8_t x_28; -x_28 = lean_ctor_get_uint8(x_9, sizeof(void*)*5 + 3); -if (x_28 == 0) +uint8_t x_29; +x_29 = lean_ctor_get_uint8(x_10, sizeof(void*)*5 + 3); +if (x_29 == 0) { -lean_object* x_29; lean_object* x_30; lean_object* x_31; +lean_object* x_30; lean_object* x_31; lean_object* x_32; +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); -lean_dec(x_11); -lean_dec(x_9); +lean_dec(x_10); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_29 = lean_ctor_get(x_27, 0); -lean_inc(x_29); -x_30 = lean_ctor_get(x_27, 1); +x_30 = lean_ctor_get(x_28, 0); lean_inc(x_30); -lean_dec(x_27); +x_31 = lean_ctor_get(x_28, 1); +lean_inc(x_31); +lean_dec(x_28); +lean_inc(x_19); lean_inc(x_18); lean_inc(x_17); lean_inc(x_16); -lean_inc(x_15); -x_31 = l_Lean_Meta_mkEqRefl(x_10, x_15, x_16, x_17, x_18, x_30); -if (lean_obj_tag(x_31) == 0) +x_32 = l_Lean_Meta_mkEqRefl(x_11, x_16, x_17, x_18, x_19, x_31); +if (lean_obj_tag(x_32) == 0) { -lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_32 = lean_ctor_get(x_31, 0); -lean_inc(x_32); -x_33 = lean_ctor_get(x_31, 1); +lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_33 = lean_ctor_get(x_32, 0); lean_inc(x_33); -lean_dec(x_31); -x_34 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(x_23, x_20, x_6, x_29, x_7, x_8, x_32, x_15, x_16, x_17, x_18, x_33); -return x_34; +x_34 = lean_ctor_get(x_32, 1); +lean_inc(x_34); +lean_dec(x_32); +x_35 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(x_24, x_21, x_6, x_30, x_7, x_8, x_9, x_33, x_16, x_17, x_18, x_19, x_34); +return x_35; } else { -uint8_t x_35; -lean_dec(x_29); -lean_dec(x_23); -lean_dec(x_20); +uint8_t x_36; +lean_dec(x_30); +lean_dec(x_24); +lean_dec(x_21); +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); +lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -x_35 = !lean_is_exclusive(x_31); -if (x_35 == 0) +x_36 = !lean_is_exclusive(x_32); +if (x_36 == 0) { -return x_31; +return x_32; } else { -lean_object* x_36; lean_object* x_37; lean_object* x_38; -x_36 = lean_ctor_get(x_31, 0); -x_37 = lean_ctor_get(x_31, 1); +lean_object* x_37; lean_object* x_38; lean_object* x_39; +x_37 = lean_ctor_get(x_32, 0); +x_38 = lean_ctor_get(x_32, 1); +lean_inc(x_38); lean_inc(x_37); -lean_inc(x_36); -lean_dec(x_31); -x_38 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_38, 0, x_36); -lean_ctor_set(x_38, 1, x_37); -return x_38; +lean_dec(x_32); +x_39 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_39, 0, x_37); +lean_ctor_set(x_39, 1, x_38); +return x_39; } } } else { -lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_39 = lean_ctor_get(x_27, 0); -lean_inc(x_39); -x_40 = lean_ctor_get(x_27, 1); +lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +x_40 = lean_ctor_get(x_28, 0); lean_inc(x_40); -lean_dec(x_27); -x_41 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_41, 0, x_9); -lean_ctor_set(x_41, 1, x_11); -lean_ctor_set(x_41, 2, x_1); -lean_ctor_set(x_41, 3, x_2); -lean_ctor_set(x_41, 4, x_3); -lean_ctor_set(x_41, 5, x_12); +x_41 = lean_ctor_get(x_28, 1); +lean_inc(x_41); +lean_dec(x_28); +x_42 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_42, 0, x_10); +lean_ctor_set(x_42, 1, x_12); +lean_ctor_set(x_42, 2, x_1); +lean_ctor_set(x_42, 3, x_2); +lean_ctor_set(x_42, 4, x_3); +lean_ctor_set(x_42, 5, x_13); +lean_inc(x_19); lean_inc(x_18); lean_inc(x_17); lean_inc(x_16); -lean_inc(x_15); -x_42 = l_Lean_Meta_SizeOfSpecNested_main(x_13, x_10, x_41, x_15, x_16, x_17, x_18, x_40); -if (lean_obj_tag(x_42) == 0) +x_43 = l_Lean_Meta_SizeOfSpecNested_main(x_14, x_11, x_42, x_16, x_17, x_18, x_19, x_41); +if (lean_obj_tag(x_43) == 0) { -lean_object* x_43; lean_object* x_44; lean_object* x_45; -x_43 = lean_ctor_get(x_42, 0); -lean_inc(x_43); -x_44 = lean_ctor_get(x_42, 1); +lean_object* x_44; lean_object* x_45; lean_object* x_46; +x_44 = lean_ctor_get(x_43, 0); lean_inc(x_44); -lean_dec(x_42); -x_45 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(x_23, x_20, x_6, x_39, x_7, x_8, x_43, x_15, x_16, x_17, x_18, x_44); -return x_45; +x_45 = lean_ctor_get(x_43, 1); +lean_inc(x_45); +lean_dec(x_43); +x_46 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__2(x_24, x_21, x_6, x_40, x_7, x_8, x_9, x_44, x_16, x_17, x_18, x_19, x_45); +return x_46; } else { -uint8_t x_46; -lean_dec(x_39); -lean_dec(x_23); -lean_dec(x_20); +uint8_t x_47; +lean_dec(x_40); +lean_dec(x_24); +lean_dec(x_21); +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); +lean_dec(x_9); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); -x_46 = !lean_is_exclusive(x_42); -if (x_46 == 0) +x_47 = !lean_is_exclusive(x_43); +if (x_47 == 0) { -return x_42; +return x_43; } else { -lean_object* x_47; lean_object* x_48; lean_object* x_49; -x_47 = lean_ctor_get(x_42, 0); -x_48 = lean_ctor_get(x_42, 1); +lean_object* x_48; lean_object* x_49; lean_object* x_50; +x_48 = lean_ctor_get(x_43, 0); +x_49 = lean_ctor_get(x_43, 1); +lean_inc(x_49); lean_inc(x_48); -lean_inc(x_47); -lean_dec(x_42); -x_49 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_49, 0, x_47); -lean_ctor_set(x_49, 1, x_48); -return x_49; +lean_dec(x_43); +x_50 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_50, 0, x_48); +lean_ctor_set(x_50, 1, x_49); +return x_50; } } } } else { -uint8_t x_50; -lean_dec(x_23); -lean_dec(x_20); +uint8_t x_51; +lean_dec(x_24); +lean_dec(x_21); +lean_dec(x_19); lean_dec(x_18); lean_dec(x_17); lean_dec(x_16); -lean_dec(x_15); +lean_dec(x_14); lean_dec(x_13); lean_dec(x_12); lean_dec(x_11); @@ -16025,23 +16062,23 @@ lean_dec(x_6); lean_dec(x_3); lean_dec(x_2); lean_dec(x_1); -x_50 = !lean_is_exclusive(x_27); -if (x_50 == 0) +x_51 = !lean_is_exclusive(x_28); +if (x_51 == 0) { -return x_27; +return x_28; } else { -lean_object* x_51; lean_object* x_52; lean_object* x_53; -x_51 = lean_ctor_get(x_27, 0); -x_52 = lean_ctor_get(x_27, 1); +lean_object* x_52; lean_object* x_53; lean_object* x_54; +x_52 = lean_ctor_get(x_28, 0); +x_53 = lean_ctor_get(x_28, 1); +lean_inc(x_53); lean_inc(x_52); -lean_inc(x_51); -lean_dec(x_27); -x_53 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_53, 0, x_51); -lean_ctor_set(x_53, 1, x_52); -return x_53; +lean_dec(x_28); +x_54 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_54, 0, x_52); +lean_ctor_set(x_54, 1, x_53); +return x_54; } } } @@ -16101,6 +16138,7 @@ x_23 = lean_ctor_get(x_21, 1); lean_inc(x_23); lean_dec(x_21); x_24 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfMotives_loop___rarg___lambda__1___closed__2; +lean_inc(x_2); x_25 = l_Lean_mkConst(x_24, x_2); x_26 = lean_unsigned_to_nat(1u); lean_inc(x_16); @@ -16197,7 +16235,7 @@ if (x_41 == 0) lean_object* x_43; lean_object* x_44; lean_dec(x_11); x_43 = lean_box(0); -x_44 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(x_4, x_5, x_12, x_3, x_38, x_6, x_7, x_40, x_8, x_35, x_9, x_10, x_22, x_43, x_13, x_14, x_15, x_16, x_42); +x_44 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(x_4, x_5, x_12, x_3, x_38, x_6, x_2, x_7, x_40, x_8, x_35, x_9, x_10, x_22, x_43, x_13, x_14, x_15, x_16, x_42); return x_44; } else @@ -16229,7 +16267,7 @@ lean_inc(x_55); x_56 = lean_ctor_get(x_54, 1); lean_inc(x_56); lean_dec(x_54); -x_57 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(x_4, x_5, x_12, x_3, x_38, x_6, x_7, x_40, x_8, x_35, x_9, x_10, x_22, x_55, x_13, x_14, x_15, x_16, x_56); +x_57 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(x_4, x_5, x_12, x_3, x_38, x_6, x_2, x_7, x_40, x_8, x_35, x_9, x_10, x_22, x_55, x_13, x_14, x_15, x_16, x_56); lean_dec(x_55); return x_57; } @@ -16254,6 +16292,7 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); +lean_dec(x_2); x_70 = !lean_is_exclusive(x_37); if (x_70 == 0) { @@ -16292,6 +16331,7 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); +lean_dec(x_2); x_74 = !lean_is_exclusive(x_34); if (x_74 == 0) { @@ -16330,6 +16370,7 @@ lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); +lean_dec(x_2); x_78 = !lean_is_exclusive(x_27); if (x_78 == 0) { @@ -16608,13 +16649,13 @@ lean_dec(x_3); return x_14; } } -LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11) { +LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { _start: { -lean_object* x_12; -x_12 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11); -lean_dec(x_6); -return x_12; +lean_object* x_13; +x_13 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12); +lean_dec(x_7); +return x_13; } } LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3___boxed(lean_object** _args) { @@ -16637,12 +16678,13 @@ lean_object* x_16 = _args[15]; lean_object* x_17 = _args[16]; lean_object* x_18 = _args[17]; lean_object* x_19 = _args[18]; +lean_object* x_20 = _args[19]; _start: { -lean_object* x_20; -x_20 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19); -lean_dec(x_14); -return x_20; +lean_object* x_21; +x_21 = l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__3(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18, x_19, x_20); +lean_dec(x_15); +return x_21; } } LEAN_EXPORT lean_object* l___private_Lean_Meta_SizeOf_0__Lean_Meta_mkSizeOfSpecTheorem___lambda__4___boxed(lean_object** _args) { @@ -17100,250 +17142,259 @@ x_3 = lean_name_mk_string(x_1, x_2); return x_3; } } -LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17) { +LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12, lean_object* x_13, lean_object* x_14, lean_object* x_15, lean_object* x_16, lean_object* x_17, lean_object* x_18) { _start: { -lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; uint8_t x_25; uint8_t x_26; uint8_t x_27; lean_object* x_28; +lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; uint8_t x_26; uint8_t x_27; uint8_t x_28; lean_object* x_29; lean_inc(x_1); -x_18 = lean_array_push(x_1, x_12); -x_19 = l_Lean_mkConst(x_2, x_3); +x_19 = lean_array_push(x_1, x_13); +x_20 = l_Lean_mkConst(x_2, x_3); lean_inc(x_5); -x_20 = l_Array_append___rarg(x_4, x_5); -x_21 = l_Array_ofSubarray___rarg(x_6); -x_22 = l_Array_append___rarg(x_20, x_21); -lean_inc(x_18); -x_23 = l_Array_append___rarg(x_22, x_18); -x_24 = l_Lean_mkAppN(x_19, x_23); -x_25 = 0; -x_26 = 1; +x_21 = l_Array_append___rarg(x_4, x_5); +x_22 = l_Array_ofSubarray___rarg(x_6); +x_23 = l_Array_append___rarg(x_21, x_22); +lean_inc(x_19); +x_24 = l_Array_append___rarg(x_23, x_19); +x_25 = l_Lean_mkAppN(x_20, x_24); +x_26 = 0; x_27 = 1; -x_28 = l_Lean_Meta_mkLambdaFVars(x_18, x_24, x_25, x_26, x_27, x_13, x_14, x_15, x_16, x_17); -if (lean_obj_tag(x_28) == 0) +x_28 = 1; +x_29 = l_Lean_Meta_mkLambdaFVars(x_19, x_25, x_26, x_27, x_28, x_14, x_15, x_16, x_17, x_18); +if (lean_obj_tag(x_29) == 0) { -lean_object* x_29; lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; -x_29 = lean_ctor_get(x_28, 0); -lean_inc(x_29); -x_30 = lean_ctor_get(x_28, 1); +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; +x_30 = lean_ctor_get(x_29, 0); lean_inc(x_30); -lean_dec(x_28); -x_31 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1___closed__1; -x_32 = lean_name_mk_string(x_7, x_31); -x_33 = lean_array_push(x_1, x_29); +x_31 = lean_ctor_get(x_29, 1); +lean_inc(x_31); +lean_dec(x_29); +x_32 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1___closed__1; +x_33 = lean_name_mk_string(x_7, x_32); +x_34 = lean_array_push(x_1, x_30); +lean_inc(x_17); lean_inc(x_16); lean_inc(x_15); lean_inc(x_14); -lean_inc(x_13); -x_34 = l_Lean_Meta_mkAppM(x_32, x_33, x_13, x_14, x_15, x_16, x_30); -if (lean_obj_tag(x_34) == 0) +x_35 = l_Lean_Meta_mkAppM(x_33, x_34, x_14, x_15, x_16, x_17, x_31); +if (lean_obj_tag(x_35) == 0) { -lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; -x_35 = lean_ctor_get(x_34, 0); -lean_inc(x_35); -x_36 = lean_ctor_get(x_34, 1); +lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; +x_36 = lean_ctor_get(x_35, 0); lean_inc(x_36); -lean_dec(x_34); -x_37 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1___closed__3; -x_38 = l_Lean_Name_append(x_8, x_37); -x_39 = l_Array_append___rarg(x_9, x_5); -lean_inc(x_39); -x_40 = l_Lean_Meta_mkForallFVars(x_39, x_10, x_25, x_26, x_27, x_13, x_14, x_15, x_16, x_36); -if (lean_obj_tag(x_40) == 0) +x_37 = lean_ctor_get(x_35, 1); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1___closed__3; +x_39 = l_Lean_Name_append(x_8, x_38); +x_40 = l_Array_append___rarg(x_9, x_5); +lean_inc(x_40); +x_41 = l_Lean_Meta_mkForallFVars(x_40, x_10, x_26, x_27, x_28, x_14, x_15, x_16, x_17, x_37); +if (lean_obj_tag(x_41) == 0) { -lean_object* x_41; lean_object* x_42; lean_object* x_43; -x_41 = lean_ctor_get(x_40, 0); -lean_inc(x_41); -x_42 = lean_ctor_get(x_40, 1); +lean_object* x_42; lean_object* x_43; lean_object* x_44; +x_42 = lean_ctor_get(x_41, 0); lean_inc(x_42); -lean_dec(x_40); -x_43 = l_Lean_Meta_mkLambdaFVars(x_39, x_35, x_25, x_26, x_27, x_13, x_14, x_15, x_16, x_42); -if (lean_obj_tag(x_43) == 0) +x_43 = lean_ctor_get(x_41, 1); +lean_inc(x_43); +lean_dec(x_41); +x_44 = l_Lean_Meta_mkLambdaFVars(x_40, x_36, x_26, x_27, x_28, x_14, x_15, x_16, x_17, x_43); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; uint8_t x_48; lean_object* x_49; lean_object* x_50; lean_object* x_51; -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -lean_inc(x_38); -x_46 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_46, 0, x_38); -lean_ctor_set(x_46, 1, x_11); -lean_ctor_set(x_46, 2, x_41); -x_47 = lean_box(1); -x_48 = 1; -x_49 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_49, 0, x_46); -lean_ctor_set(x_49, 1, x_44); -lean_ctor_set(x_49, 2, x_47); -lean_ctor_set_uint8(x_49, sizeof(void*)*3, x_48); -x_50 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_50, 0, x_49); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +lean_inc(x_39); +x_47 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_47, 0, x_39); +lean_ctor_set(x_47, 1, x_11); +lean_ctor_set(x_47, 2, x_42); +lean_inc(x_39); +x_48 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_48, 0, x_39); +lean_ctor_set(x_48, 1, x_12); +x_49 = lean_box(1); +x_50 = 1; +x_51 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_51, 0, x_47); +lean_ctor_set(x_51, 1, x_45); +lean_ctor_set(x_51, 2, x_49); +lean_ctor_set(x_51, 3, x_48); +lean_ctor_set_uint8(x_51, sizeof(void*)*4, x_50); +x_52 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_52, 0, x_51); +lean_inc(x_17); lean_inc(x_16); lean_inc(x_15); lean_inc(x_14); -lean_inc(x_13); -x_51 = l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3(x_50, x_13, x_14, x_15, x_16, x_45); -if (lean_obj_tag(x_51) == 0) +x_53 = l_Lean_addDecl___at_Lean_Meta_mkSizeOfFn___spec__3(x_52, x_14, x_15, x_16, x_17, x_46); +if (lean_obj_tag(x_53) == 0) { -lean_object* x_52; uint8_t x_53; lean_object* x_54; lean_object* x_55; -x_52 = lean_ctor_get(x_51, 1); -lean_inc(x_52); -lean_dec(x_51); -x_53 = 0; -x_54 = lean_unsigned_to_nat(1000u); -x_55 = l_Lean_Meta_addInstance(x_38, x_53, x_54, x_13, x_14, x_15, x_16, x_52); -return x_55; +lean_object* x_54; uint8_t x_55; lean_object* x_56; lean_object* x_57; +x_54 = lean_ctor_get(x_53, 1); +lean_inc(x_54); +lean_dec(x_53); +x_55 = 0; +x_56 = lean_unsigned_to_nat(1000u); +x_57 = l_Lean_Meta_addInstance(x_39, x_55, x_56, x_14, x_15, x_16, x_17, x_54); +return x_57; } else { -uint8_t x_56; -lean_dec(x_38); -lean_dec(x_16); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -x_56 = !lean_is_exclusive(x_51); -if (x_56 == 0) -{ -return x_51; -} -else -{ -lean_object* x_57; lean_object* x_58; lean_object* x_59; -x_57 = lean_ctor_get(x_51, 0); -x_58 = lean_ctor_get(x_51, 1); -lean_inc(x_58); -lean_inc(x_57); -lean_dec(x_51); -x_59 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_59, 0, x_57); -lean_ctor_set(x_59, 1, x_58); -return x_59; -} -} -} -else -{ -uint8_t x_60; -lean_dec(x_41); -lean_dec(x_38); -lean_dec(x_16); -lean_dec(x_15); -lean_dec(x_14); -lean_dec(x_13); -lean_dec(x_11); -x_60 = !lean_is_exclusive(x_43); -if (x_60 == 0) -{ -return x_43; -} -else -{ -lean_object* x_61; lean_object* x_62; lean_object* x_63; -x_61 = lean_ctor_get(x_43, 0); -x_62 = lean_ctor_get(x_43, 1); -lean_inc(x_62); -lean_inc(x_61); -lean_dec(x_43); -x_63 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_63, 0, x_61); -lean_ctor_set(x_63, 1, x_62); -return x_63; -} -} -} -else -{ -uint8_t x_64; +uint8_t x_58; lean_dec(x_39); -lean_dec(x_38); -lean_dec(x_35); +lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -lean_dec(x_13); +x_58 = !lean_is_exclusive(x_53); +if (x_58 == 0) +{ +return x_53; +} +else +{ +lean_object* x_59; lean_object* x_60; lean_object* x_61; +x_59 = lean_ctor_get(x_53, 0); +x_60 = lean_ctor_get(x_53, 1); +lean_inc(x_60); +lean_inc(x_59); +lean_dec(x_53); +x_61 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_61, 0, x_59); +lean_ctor_set(x_61, 1, x_60); +return x_61; +} +} +} +else +{ +uint8_t x_62; +lean_dec(x_42); +lean_dec(x_39); +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_12); lean_dec(x_11); -x_64 = !lean_is_exclusive(x_40); -if (x_64 == 0) +x_62 = !lean_is_exclusive(x_44); +if (x_62 == 0) { -return x_40; +return x_44; } else { -lean_object* x_65; lean_object* x_66; lean_object* x_67; -x_65 = lean_ctor_get(x_40, 0); -x_66 = lean_ctor_get(x_40, 1); -lean_inc(x_66); -lean_inc(x_65); +lean_object* x_63; lean_object* x_64; lean_object* x_65; +x_63 = lean_ctor_get(x_44, 0); +x_64 = lean_ctor_get(x_44, 1); +lean_inc(x_64); +lean_inc(x_63); +lean_dec(x_44); +x_65 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_65, 0, x_63); +lean_ctor_set(x_65, 1, x_64); +return x_65; +} +} +} +else +{ +uint8_t x_66; lean_dec(x_40); -x_67 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_67, 0, x_65); -lean_ctor_set(x_67, 1, x_66); -return x_67; -} -} -} -else -{ -uint8_t x_68; +lean_dec(x_39); +lean_dec(x_36); +lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -lean_dec(x_13); +lean_dec(x_12); +lean_dec(x_11); +x_66 = !lean_is_exclusive(x_41); +if (x_66 == 0) +{ +return x_41; +} +else +{ +lean_object* x_67; lean_object* x_68; lean_object* x_69; +x_67 = lean_ctor_get(x_41, 0); +x_68 = lean_ctor_get(x_41, 1); +lean_inc(x_68); +lean_inc(x_67); +lean_dec(x_41); +x_69 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_69, 0, x_67); +lean_ctor_set(x_69, 1, x_68); +return x_69; +} +} +} +else +{ +uint8_t x_70; +lean_dec(x_17); +lean_dec(x_16); +lean_dec(x_15); +lean_dec(x_14); +lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); lean_dec(x_5); -x_68 = !lean_is_exclusive(x_34); -if (x_68 == 0) +x_70 = !lean_is_exclusive(x_35); +if (x_70 == 0) { -return x_34; +return x_35; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_34, 0); -x_70 = lean_ctor_get(x_34, 1); -lean_inc(x_70); -lean_inc(x_69); -lean_dec(x_34); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +lean_object* x_71; lean_object* x_72; lean_object* x_73; +x_71 = lean_ctor_get(x_35, 0); +x_72 = lean_ctor_get(x_35, 1); +lean_inc(x_72); +lean_inc(x_71); +lean_dec(x_35); +x_73 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_73, 0, x_71); +lean_ctor_set(x_73, 1, x_72); +return x_73; } } } else { -uint8_t x_72; +uint8_t x_74; +lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -lean_dec(x_13); +lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); lean_dec(x_9); lean_dec(x_7); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_28); -if (x_72 == 0) +x_74 = !lean_is_exclusive(x_29); +if (x_74 == 0) { -return x_28; +return x_29; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_28, 0); -x_74 = lean_ctor_get(x_28, 1); -lean_inc(x_74); -lean_inc(x_73); -lean_dec(x_28); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +lean_object* x_75; lean_object* x_76; lean_object* x_77; +x_75 = lean_ctor_get(x_29, 0); +x_76 = lean_ctor_get(x_29, 1); +lean_inc(x_76); +lean_inc(x_75); +lean_dec(x_29); +x_77 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_77, 0, x_75); +lean_ctor_set(x_77, 1, x_76); +return x_77; } } } @@ -17398,7 +17449,7 @@ lean_inc(x_22); x_23 = lean_ctor_get(x_21, 1); lean_inc(x_23); lean_dec(x_21); -x_24 = lean_alloc_closure((void*)(l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1___boxed), 17, 11); +x_24 = lean_alloc_closure((void*)(l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1___boxed), 18, 12); lean_closure_set(x_24, 0, x_19); lean_closure_set(x_24, 1, x_5); lean_closure_set(x_24, 2, x_16); @@ -17410,6 +17461,7 @@ lean_closure_set(x_24, 7, x_2); lean_closure_set(x_24, 8, x_3); lean_closure_set(x_24, 9, x_22); lean_closure_set(x_24, 10, x_14); +lean_closure_set(x_24, 11, x_15); x_25 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__2___closed__2; x_26 = 0; x_27 = l_Lean_Meta_withLocalDecl___at___private_Lean_Meta_SynthInstance_0__Lean_Meta_SynthInstance_removeUnusedArguments_x3f___spec__2___rarg(x_25, x_26, x_18, x_24, x_9, x_10, x_11, x_12, x_23); @@ -18460,12 +18512,13 @@ lean_object* x_14 = _args[13]; lean_object* x_15 = _args[14]; lean_object* x_16 = _args[15]; lean_object* x_17 = _args[16]; +lean_object* x_18 = _args[17]; _start: { -lean_object* x_18; -x_18 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17); +lean_object* x_19; +x_19 = l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__1(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_9, x_10, x_11, x_12, x_13, x_14, x_15, x_16, x_17, x_18); lean_dec(x_8); -return x_18; +return x_19; } } LEAN_EXPORT lean_object* l_List_forIn_loop___at_Lean_Meta_mkSizeOfInstances___spec__1___lambda__3___boxed(lean_object* x_1, lean_object* x_2, lean_object* x_3, lean_object* x_4, lean_object* x_5, lean_object* x_6, lean_object* x_7, lean_object* x_8, lean_object* x_9, lean_object* x_10, lean_object* x_11, lean_object* x_12) { diff --git a/stage0/stdlib/Lean/Meta/Tactic/AuxLemma.c b/stage0/stdlib/Lean/Meta/Tactic/AuxLemma.c index ec94f9ca5e..abf810ee74 100644 --- a/stage0/stdlib/Lean/Meta/Tactic/AuxLemma.c +++ b/stage0/stdlib/Lean/Meta/Tactic/AuxLemma.c @@ -2083,7 +2083,7 @@ x_9 = lean_st_ref_get(x_7, x_8); x_10 = !lean_is_exclusive(x_9); if (x_10 == 0) { -lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; +lean_object* x_11; lean_object* x_12; lean_object* x_13; lean_object* x_14; lean_object* x_15; lean_object* x_16; lean_object* x_17; lean_object* x_18; lean_object* x_19; lean_object* x_20; lean_object* x_21; lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; x_11 = lean_ctor_get(x_9, 0); x_12 = lean_ctor_get(x_9, 1); x_13 = lean_ctor_get(x_11, 0); @@ -2106,509 +2106,515 @@ x_22 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_22, 0, x_21); lean_ctor_set(x_22, 1, x_1); lean_ctor_set(x_22, 2, x_2); -x_23 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_23, 0, x_22); -lean_ctor_set(x_23, 1, x_3); -x_24 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_24, 0, x_23); -x_25 = lean_ctor_get(x_16, 1); -lean_inc(x_25); +x_23 = lean_box(0); +lean_inc(x_21); +x_24 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_24, 0, x_21); +lean_ctor_set(x_24, 1, x_23); +x_25 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_25, 0, x_22); +lean_ctor_set(x_25, 1, x_3); +lean_ctor_set(x_25, 2, x_24); +x_26 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_26, 0, x_25); +x_27 = lean_ctor_get(x_16, 1); +lean_inc(x_27); lean_dec(x_16); lean_inc(x_2); -x_26 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_mkAuxLemma___spec__1(x_25, x_2); -if (lean_obj_tag(x_26) == 0) +x_28 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_mkAuxLemma___spec__1(x_27, x_2); +if (lean_obj_tag(x_28) == 0) { -lean_object* x_27; +lean_object* x_29; lean_free_object(x_9); lean_inc(x_7); lean_inc(x_5); -x_27 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_24, x_4, x_5, x_6, x_7, x_12); -if (lean_obj_tag(x_27) == 0) +x_29 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_26, x_4, x_5, x_6, x_7, x_12); +if (lean_obj_tag(x_29) == 0) { -lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; -x_28 = lean_ctor_get(x_27, 1); -lean_inc(x_28); -lean_dec(x_27); -x_29 = lean_st_ref_take(x_7, x_28); -x_30 = lean_ctor_get(x_29, 0); +lean_object* x_30; lean_object* x_31; lean_object* x_32; lean_object* x_33; uint8_t x_34; +x_30 = lean_ctor_get(x_29, 1); lean_inc(x_30); -x_31 = lean_ctor_get(x_29, 1); -lean_inc(x_31); lean_dec(x_29); -x_32 = !lean_is_exclusive(x_30); -if (x_32 == 0) +x_31 = lean_st_ref_take(x_7, x_30); +x_32 = lean_ctor_get(x_31, 0); +lean_inc(x_32); +x_33 = lean_ctor_get(x_31, 1); +lean_inc(x_33); +lean_dec(x_31); +x_34 = !lean_is_exclusive(x_32); +if (x_34 == 0) { -lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; uint8_t x_45; -x_33 = lean_ctor_get(x_30, 0); -x_34 = lean_ctor_get(x_30, 4); -lean_dec(x_34); +lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_object* x_45; lean_object* x_46; uint8_t x_47; +x_35 = lean_ctor_get(x_32, 0); +x_36 = lean_ctor_get(x_32, 4); +lean_dec(x_36); lean_inc(x_21); -x_35 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); -lean_closure_set(x_35, 0, x_21); -lean_closure_set(x_35, 1, x_1); -lean_closure_set(x_35, 2, x_2); -x_36 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_33, x_35); -x_37 = l_Lean_Meta_mkAuxLemma___closed__5; -lean_ctor_set(x_30, 4, x_37); -lean_ctor_set(x_30, 0, x_36); -x_38 = lean_st_ref_set(x_7, x_30, x_31); -x_39 = lean_ctor_get(x_38, 1); -lean_inc(x_39); -lean_dec(x_38); -x_40 = lean_st_ref_get(x_7, x_39); -lean_dec(x_7); +x_37 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); +lean_closure_set(x_37, 0, x_21); +lean_closure_set(x_37, 1, x_1); +lean_closure_set(x_37, 2, x_2); +x_38 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_35, x_37); +x_39 = l_Lean_Meta_mkAuxLemma___closed__5; +lean_ctor_set(x_32, 4, x_39); +lean_ctor_set(x_32, 0, x_38); +x_40 = lean_st_ref_set(x_7, x_32, x_33); x_41 = lean_ctor_get(x_40, 1); lean_inc(x_41); lean_dec(x_40); -x_42 = lean_st_ref_take(x_5, x_41); -x_43 = lean_ctor_get(x_42, 0); +x_42 = lean_st_ref_get(x_7, x_41); +lean_dec(x_7); +x_43 = lean_ctor_get(x_42, 1); lean_inc(x_43); -x_44 = lean_ctor_get(x_42, 1); -lean_inc(x_44); lean_dec(x_42); -x_45 = !lean_is_exclusive(x_43); -if (x_45 == 0) +x_44 = lean_st_ref_take(x_5, x_43); +x_45 = lean_ctor_get(x_44, 0); +lean_inc(x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = !lean_is_exclusive(x_45); +if (x_47 == 0) { -lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -x_46 = lean_ctor_get(x_43, 1); -lean_dec(x_46); -x_47 = l_Lean_Meta_mkAuxLemma___closed__12; -lean_ctor_set(x_43, 1, x_47); -x_48 = lean_st_ref_set(x_5, x_43, x_44); -lean_dec(x_5); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) -{ -lean_object* x_50; -x_50 = lean_ctor_get(x_48, 0); -lean_dec(x_50); -lean_ctor_set(x_48, 0, x_21); -return x_48; -} -else -{ -lean_object* x_51; lean_object* x_52; -x_51 = lean_ctor_get(x_48, 1); -lean_inc(x_51); +lean_object* x_48; lean_object* x_49; lean_object* x_50; uint8_t x_51; +x_48 = lean_ctor_get(x_45, 1); lean_dec(x_48); -x_52 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_52, 0, x_21); -lean_ctor_set(x_52, 1, x_51); -return x_52; -} -} -else -{ -lean_object* x_53; lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; -x_53 = lean_ctor_get(x_43, 0); -x_54 = lean_ctor_get(x_43, 2); -x_55 = lean_ctor_get(x_43, 3); -lean_inc(x_55); -lean_inc(x_54); -lean_inc(x_53); -lean_dec(x_43); -x_56 = l_Lean_Meta_mkAuxLemma___closed__12; -x_57 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_57, 0, x_53); -lean_ctor_set(x_57, 1, x_56); -lean_ctor_set(x_57, 2, x_54); -lean_ctor_set(x_57, 3, x_55); -x_58 = lean_st_ref_set(x_5, x_57, x_44); +x_49 = l_Lean_Meta_mkAuxLemma___closed__12; +lean_ctor_set(x_45, 1, x_49); +x_50 = lean_st_ref_set(x_5, x_45, x_46); lean_dec(x_5); -x_59 = lean_ctor_get(x_58, 1); -lean_inc(x_59); -if (lean_is_exclusive(x_58)) { - lean_ctor_release(x_58, 0); - lean_ctor_release(x_58, 1); - x_60 = x_58; -} else { - lean_dec_ref(x_58); - x_60 = lean_box(0); +x_51 = !lean_is_exclusive(x_50); +if (x_51 == 0) +{ +lean_object* x_52; +x_52 = lean_ctor_get(x_50, 0); +lean_dec(x_52); +lean_ctor_set(x_50, 0, x_21); +return x_50; } -if (lean_is_scalar(x_60)) { - x_61 = lean_alloc_ctor(0, 2, 0); -} else { - x_61 = x_60; -} -lean_ctor_set(x_61, 0, x_21); -lean_ctor_set(x_61, 1, x_59); -return x_61; +else +{ +lean_object* x_53; lean_object* x_54; +x_53 = lean_ctor_get(x_50, 1); +lean_inc(x_53); +lean_dec(x_50); +x_54 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_54, 0, x_21); +lean_ctor_set(x_54, 1, x_53); +return x_54; } } else { -lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; -x_62 = lean_ctor_get(x_30, 0); -x_63 = lean_ctor_get(x_30, 1); -x_64 = lean_ctor_get(x_30, 2); -x_65 = lean_ctor_get(x_30, 3); -x_66 = lean_ctor_get(x_30, 5); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; +x_55 = lean_ctor_get(x_45, 0); +x_56 = lean_ctor_get(x_45, 2); +x_57 = lean_ctor_get(x_45, 3); +lean_inc(x_57); +lean_inc(x_56); +lean_inc(x_55); +lean_dec(x_45); +x_58 = l_Lean_Meta_mkAuxLemma___closed__12; +x_59 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_59, 0, x_55); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_59, 2, x_56); +lean_ctor_set(x_59, 3, x_57); +x_60 = lean_st_ref_set(x_5, x_59, x_46); +lean_dec(x_5); +x_61 = lean_ctor_get(x_60, 1); +lean_inc(x_61); +if (lean_is_exclusive(x_60)) { + lean_ctor_release(x_60, 0); + lean_ctor_release(x_60, 1); + x_62 = x_60; +} else { + lean_dec_ref(x_60); + x_62 = lean_box(0); +} +if (lean_is_scalar(x_62)) { + x_63 = lean_alloc_ctor(0, 2, 0); +} else { + x_63 = x_62; +} +lean_ctor_set(x_63, 0, x_21); +lean_ctor_set(x_63, 1, x_61); +return x_63; +} +} +else +{ +lean_object* x_64; lean_object* x_65; lean_object* x_66; lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; +x_64 = lean_ctor_get(x_32, 0); +x_65 = lean_ctor_get(x_32, 1); +x_66 = lean_ctor_get(x_32, 2); +x_67 = lean_ctor_get(x_32, 3); +x_68 = lean_ctor_get(x_32, 5); +lean_inc(x_68); +lean_inc(x_67); lean_inc(x_66); lean_inc(x_65); lean_inc(x_64); -lean_inc(x_63); -lean_inc(x_62); -lean_dec(x_30); +lean_dec(x_32); lean_inc(x_21); -x_67 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); -lean_closure_set(x_67, 0, x_21); -lean_closure_set(x_67, 1, x_1); -lean_closure_set(x_67, 2, x_2); -x_68 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_62, x_67); -x_69 = l_Lean_Meta_mkAuxLemma___closed__5; -x_70 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_70, 0, x_68); -lean_ctor_set(x_70, 1, x_63); -lean_ctor_set(x_70, 2, x_64); -lean_ctor_set(x_70, 3, x_65); -lean_ctor_set(x_70, 4, x_69); -lean_ctor_set(x_70, 5, x_66); -x_71 = lean_st_ref_set(x_7, x_70, x_31); -x_72 = lean_ctor_get(x_71, 1); -lean_inc(x_72); -lean_dec(x_71); -x_73 = lean_st_ref_get(x_7, x_72); -lean_dec(x_7); +x_69 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); +lean_closure_set(x_69, 0, x_21); +lean_closure_set(x_69, 1, x_1); +lean_closure_set(x_69, 2, x_2); +x_70 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_64, x_69); +x_71 = l_Lean_Meta_mkAuxLemma___closed__5; +x_72 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_65); +lean_ctor_set(x_72, 2, x_66); +lean_ctor_set(x_72, 3, x_67); +lean_ctor_set(x_72, 4, x_71); +lean_ctor_set(x_72, 5, x_68); +x_73 = lean_st_ref_set(x_7, x_72, x_33); x_74 = lean_ctor_get(x_73, 1); lean_inc(x_74); lean_dec(x_73); -x_75 = lean_st_ref_take(x_5, x_74); -x_76 = lean_ctor_get(x_75, 0); +x_75 = lean_st_ref_get(x_7, x_74); +lean_dec(x_7); +x_76 = lean_ctor_get(x_75, 1); lean_inc(x_76); -x_77 = lean_ctor_get(x_75, 1); -lean_inc(x_77); lean_dec(x_75); -x_78 = lean_ctor_get(x_76, 0); +x_77 = lean_st_ref_take(x_5, x_76); +x_78 = lean_ctor_get(x_77, 0); lean_inc(x_78); -x_79 = lean_ctor_get(x_76, 2); +x_79 = lean_ctor_get(x_77, 1); lean_inc(x_79); -x_80 = lean_ctor_get(x_76, 3); +lean_dec(x_77); +x_80 = lean_ctor_get(x_78, 0); lean_inc(x_80); -if (lean_is_exclusive(x_76)) { - lean_ctor_release(x_76, 0); - lean_ctor_release(x_76, 1); - lean_ctor_release(x_76, 2); - lean_ctor_release(x_76, 3); - x_81 = x_76; +x_81 = lean_ctor_get(x_78, 2); +lean_inc(x_81); +x_82 = lean_ctor_get(x_78, 3); +lean_inc(x_82); +if (lean_is_exclusive(x_78)) { + lean_ctor_release(x_78, 0); + lean_ctor_release(x_78, 1); + lean_ctor_release(x_78, 2); + lean_ctor_release(x_78, 3); + x_83 = x_78; } else { - lean_dec_ref(x_76); - x_81 = lean_box(0); + lean_dec_ref(x_78); + x_83 = lean_box(0); } -x_82 = l_Lean_Meta_mkAuxLemma___closed__12; -if (lean_is_scalar(x_81)) { - x_83 = lean_alloc_ctor(0, 4, 0); +x_84 = l_Lean_Meta_mkAuxLemma___closed__12; +if (lean_is_scalar(x_83)) { + x_85 = lean_alloc_ctor(0, 4, 0); } else { - x_83 = x_81; + x_85 = x_83; } -lean_ctor_set(x_83, 0, x_78); -lean_ctor_set(x_83, 1, x_82); -lean_ctor_set(x_83, 2, x_79); -lean_ctor_set(x_83, 3, x_80); -x_84 = lean_st_ref_set(x_5, x_83, x_77); +lean_ctor_set(x_85, 0, x_80); +lean_ctor_set(x_85, 1, x_84); +lean_ctor_set(x_85, 2, x_81); +lean_ctor_set(x_85, 3, x_82); +x_86 = lean_st_ref_set(x_5, x_85, x_79); lean_dec(x_5); -x_85 = lean_ctor_get(x_84, 1); -lean_inc(x_85); -if (lean_is_exclusive(x_84)) { - lean_ctor_release(x_84, 0); - lean_ctor_release(x_84, 1); - x_86 = x_84; +x_87 = lean_ctor_get(x_86, 1); +lean_inc(x_87); +if (lean_is_exclusive(x_86)) { + lean_ctor_release(x_86, 0); + lean_ctor_release(x_86, 1); + x_88 = x_86; } else { - lean_dec_ref(x_84); - x_86 = lean_box(0); + lean_dec_ref(x_86); + x_88 = lean_box(0); } -if (lean_is_scalar(x_86)) { - x_87 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_88)) { + x_89 = lean_alloc_ctor(0, 2, 0); } else { - x_87 = x_86; + x_89 = x_88; } -lean_ctor_set(x_87, 0, x_21); -lean_ctor_set(x_87, 1, x_85); -return x_87; +lean_ctor_set(x_89, 0, x_21); +lean_ctor_set(x_89, 1, x_87); +return x_89; } } else { -uint8_t x_88; +uint8_t x_90; lean_dec(x_21); lean_dec(x_7); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_88 = !lean_is_exclusive(x_27); -if (x_88 == 0) +x_90 = !lean_is_exclusive(x_29); +if (x_90 == 0) { -return x_27; +return x_29; } else { -lean_object* x_89; lean_object* x_90; lean_object* x_91; -x_89 = lean_ctor_get(x_27, 0); -x_90 = lean_ctor_get(x_27, 1); -lean_inc(x_90); -lean_inc(x_89); -lean_dec(x_27); -x_91 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_91, 0, x_89); -lean_ctor_set(x_91, 1, x_90); -return x_91; -} -} -} -else -{ -lean_object* x_92; lean_object* x_93; lean_object* x_94; uint8_t x_95; -x_92 = lean_ctor_get(x_26, 0); +lean_object* x_91; lean_object* x_92; lean_object* x_93; +x_91 = lean_ctor_get(x_29, 0); +x_92 = lean_ctor_get(x_29, 1); lean_inc(x_92); -lean_dec(x_26); -x_93 = lean_ctor_get(x_92, 0); -lean_inc(x_93); -x_94 = lean_ctor_get(x_92, 1); -lean_inc(x_94); -lean_dec(x_92); -x_95 = l_List_beq___at_Lean_OpenDecl_instToStringOpenDecl___spec__1(x_1, x_94); -lean_dec(x_94); -if (x_95 == 0) +lean_inc(x_91); +lean_dec(x_29); +x_93 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_93, 0, x_91); +lean_ctor_set(x_93, 1, x_92); +return x_93; +} +} +} +else { -lean_object* x_96; -lean_dec(x_93); +lean_object* x_94; lean_object* x_95; lean_object* x_96; uint8_t x_97; +x_94 = lean_ctor_get(x_28, 0); +lean_inc(x_94); +lean_dec(x_28); +x_95 = lean_ctor_get(x_94, 0); +lean_inc(x_95); +x_96 = lean_ctor_get(x_94, 1); +lean_inc(x_96); +lean_dec(x_94); +x_97 = l_List_beq___at_Lean_OpenDecl_instToStringOpenDecl___spec__1(x_1, x_96); +lean_dec(x_96); +if (x_97 == 0) +{ +lean_object* x_98; +lean_dec(x_95); lean_free_object(x_9); lean_inc(x_7); lean_inc(x_5); -x_96 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_24, x_4, x_5, x_6, x_7, x_12); -if (lean_obj_tag(x_96) == 0) +x_98 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_26, x_4, x_5, x_6, x_7, x_12); +if (lean_obj_tag(x_98) == 0) { -lean_object* x_97; lean_object* x_98; lean_object* x_99; lean_object* x_100; uint8_t x_101; -x_97 = lean_ctor_get(x_96, 1); -lean_inc(x_97); -lean_dec(x_96); -x_98 = lean_st_ref_take(x_7, x_97); -x_99 = lean_ctor_get(x_98, 0); +lean_object* x_99; lean_object* x_100; lean_object* x_101; lean_object* x_102; uint8_t x_103; +x_99 = lean_ctor_get(x_98, 1); lean_inc(x_99); -x_100 = lean_ctor_get(x_98, 1); -lean_inc(x_100); lean_dec(x_98); -x_101 = !lean_is_exclusive(x_99); -if (x_101 == 0) +x_100 = lean_st_ref_take(x_7, x_99); +x_101 = lean_ctor_get(x_100, 0); +lean_inc(x_101); +x_102 = lean_ctor_get(x_100, 1); +lean_inc(x_102); +lean_dec(x_100); +x_103 = !lean_is_exclusive(x_101); +if (x_103 == 0) { -lean_object* x_102; lean_object* x_103; lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; uint8_t x_114; -x_102 = lean_ctor_get(x_99, 0); -x_103 = lean_ctor_get(x_99, 4); -lean_dec(x_103); +lean_object* x_104; lean_object* x_105; lean_object* x_106; lean_object* x_107; lean_object* x_108; lean_object* x_109; lean_object* x_110; lean_object* x_111; lean_object* x_112; lean_object* x_113; lean_object* x_114; lean_object* x_115; uint8_t x_116; +x_104 = lean_ctor_get(x_101, 0); +x_105 = lean_ctor_get(x_101, 4); +lean_dec(x_105); lean_inc(x_21); -x_104 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); -lean_closure_set(x_104, 0, x_21); -lean_closure_set(x_104, 1, x_1); -lean_closure_set(x_104, 2, x_2); -x_105 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_102, x_104); -x_106 = l_Lean_Meta_mkAuxLemma___closed__5; -lean_ctor_set(x_99, 4, x_106); -lean_ctor_set(x_99, 0, x_105); -x_107 = lean_st_ref_set(x_7, x_99, x_100); -x_108 = lean_ctor_get(x_107, 1); -lean_inc(x_108); -lean_dec(x_107); -x_109 = lean_st_ref_get(x_7, x_108); -lean_dec(x_7); +x_106 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); +lean_closure_set(x_106, 0, x_21); +lean_closure_set(x_106, 1, x_1); +lean_closure_set(x_106, 2, x_2); +x_107 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_104, x_106); +x_108 = l_Lean_Meta_mkAuxLemma___closed__5; +lean_ctor_set(x_101, 4, x_108); +lean_ctor_set(x_101, 0, x_107); +x_109 = lean_st_ref_set(x_7, x_101, x_102); x_110 = lean_ctor_get(x_109, 1); lean_inc(x_110); lean_dec(x_109); -x_111 = lean_st_ref_take(x_5, x_110); -x_112 = lean_ctor_get(x_111, 0); +x_111 = lean_st_ref_get(x_7, x_110); +lean_dec(x_7); +x_112 = lean_ctor_get(x_111, 1); lean_inc(x_112); -x_113 = lean_ctor_get(x_111, 1); -lean_inc(x_113); lean_dec(x_111); -x_114 = !lean_is_exclusive(x_112); -if (x_114 == 0) +x_113 = lean_st_ref_take(x_5, x_112); +x_114 = lean_ctor_get(x_113, 0); +lean_inc(x_114); +x_115 = lean_ctor_get(x_113, 1); +lean_inc(x_115); +lean_dec(x_113); +x_116 = !lean_is_exclusive(x_114); +if (x_116 == 0) { -lean_object* x_115; lean_object* x_116; lean_object* x_117; uint8_t x_118; -x_115 = lean_ctor_get(x_112, 1); -lean_dec(x_115); -x_116 = l_Lean_Meta_mkAuxLemma___closed__12; -lean_ctor_set(x_112, 1, x_116); -x_117 = lean_st_ref_set(x_5, x_112, x_113); -lean_dec(x_5); -x_118 = !lean_is_exclusive(x_117); -if (x_118 == 0) -{ -lean_object* x_119; -x_119 = lean_ctor_get(x_117, 0); -lean_dec(x_119); -lean_ctor_set(x_117, 0, x_21); -return x_117; -} -else -{ -lean_object* x_120; lean_object* x_121; -x_120 = lean_ctor_get(x_117, 1); -lean_inc(x_120); +lean_object* x_117; lean_object* x_118; lean_object* x_119; uint8_t x_120; +x_117 = lean_ctor_get(x_114, 1); lean_dec(x_117); -x_121 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_121, 0, x_21); -lean_ctor_set(x_121, 1, x_120); -return x_121; -} -} -else -{ -lean_object* x_122; lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; -x_122 = lean_ctor_get(x_112, 0); -x_123 = lean_ctor_get(x_112, 2); -x_124 = lean_ctor_get(x_112, 3); -lean_inc(x_124); -lean_inc(x_123); -lean_inc(x_122); -lean_dec(x_112); -x_125 = l_Lean_Meta_mkAuxLemma___closed__12; -x_126 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_126, 0, x_122); -lean_ctor_set(x_126, 1, x_125); -lean_ctor_set(x_126, 2, x_123); -lean_ctor_set(x_126, 3, x_124); -x_127 = lean_st_ref_set(x_5, x_126, x_113); +x_118 = l_Lean_Meta_mkAuxLemma___closed__12; +lean_ctor_set(x_114, 1, x_118); +x_119 = lean_st_ref_set(x_5, x_114, x_115); lean_dec(x_5); -x_128 = lean_ctor_get(x_127, 1); -lean_inc(x_128); -if (lean_is_exclusive(x_127)) { - lean_ctor_release(x_127, 0); - lean_ctor_release(x_127, 1); - x_129 = x_127; -} else { - lean_dec_ref(x_127); - x_129 = lean_box(0); +x_120 = !lean_is_exclusive(x_119); +if (x_120 == 0) +{ +lean_object* x_121; +x_121 = lean_ctor_get(x_119, 0); +lean_dec(x_121); +lean_ctor_set(x_119, 0, x_21); +return x_119; } -if (lean_is_scalar(x_129)) { - x_130 = lean_alloc_ctor(0, 2, 0); -} else { - x_130 = x_129; -} -lean_ctor_set(x_130, 0, x_21); -lean_ctor_set(x_130, 1, x_128); -return x_130; +else +{ +lean_object* x_122; lean_object* x_123; +x_122 = lean_ctor_get(x_119, 1); +lean_inc(x_122); +lean_dec(x_119); +x_123 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_123, 0, x_21); +lean_ctor_set(x_123, 1, x_122); +return x_123; } } else { -lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; -x_131 = lean_ctor_get(x_99, 0); -x_132 = lean_ctor_get(x_99, 1); -x_133 = lean_ctor_get(x_99, 2); -x_134 = lean_ctor_get(x_99, 3); -x_135 = lean_ctor_get(x_99, 5); +lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; +x_124 = lean_ctor_get(x_114, 0); +x_125 = lean_ctor_get(x_114, 2); +x_126 = lean_ctor_get(x_114, 3); +lean_inc(x_126); +lean_inc(x_125); +lean_inc(x_124); +lean_dec(x_114); +x_127 = l_Lean_Meta_mkAuxLemma___closed__12; +x_128 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_128, 0, x_124); +lean_ctor_set(x_128, 1, x_127); +lean_ctor_set(x_128, 2, x_125); +lean_ctor_set(x_128, 3, x_126); +x_129 = lean_st_ref_set(x_5, x_128, x_115); +lean_dec(x_5); +x_130 = lean_ctor_get(x_129, 1); +lean_inc(x_130); +if (lean_is_exclusive(x_129)) { + lean_ctor_release(x_129, 0); + lean_ctor_release(x_129, 1); + x_131 = x_129; +} else { + lean_dec_ref(x_129); + x_131 = lean_box(0); +} +if (lean_is_scalar(x_131)) { + x_132 = lean_alloc_ctor(0, 2, 0); +} else { + x_132 = x_131; +} +lean_ctor_set(x_132, 0, x_21); +lean_ctor_set(x_132, 1, x_130); +return x_132; +} +} +else +{ +lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; lean_object* x_143; lean_object* x_144; lean_object* x_145; lean_object* x_146; lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_object* x_150; lean_object* x_151; lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; lean_object* x_157; lean_object* x_158; +x_133 = lean_ctor_get(x_101, 0); +x_134 = lean_ctor_get(x_101, 1); +x_135 = lean_ctor_get(x_101, 2); +x_136 = lean_ctor_get(x_101, 3); +x_137 = lean_ctor_get(x_101, 5); +lean_inc(x_137); +lean_inc(x_136); lean_inc(x_135); lean_inc(x_134); lean_inc(x_133); -lean_inc(x_132); -lean_inc(x_131); -lean_dec(x_99); +lean_dec(x_101); lean_inc(x_21); -x_136 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); -lean_closure_set(x_136, 0, x_21); -lean_closure_set(x_136, 1, x_1); -lean_closure_set(x_136, 2, x_2); -x_137 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_131, x_136); -x_138 = l_Lean_Meta_mkAuxLemma___closed__5; -x_139 = lean_alloc_ctor(0, 6, 0); -lean_ctor_set(x_139, 0, x_137); -lean_ctor_set(x_139, 1, x_132); -lean_ctor_set(x_139, 2, x_133); -lean_ctor_set(x_139, 3, x_134); -lean_ctor_set(x_139, 4, x_138); -lean_ctor_set(x_139, 5, x_135); -x_140 = lean_st_ref_set(x_7, x_139, x_100); -x_141 = lean_ctor_get(x_140, 1); -lean_inc(x_141); -lean_dec(x_140); -x_142 = lean_st_ref_get(x_7, x_141); -lean_dec(x_7); +x_138 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); +lean_closure_set(x_138, 0, x_21); +lean_closure_set(x_138, 1, x_1); +lean_closure_set(x_138, 2, x_2); +x_139 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_15, x_133, x_138); +x_140 = l_Lean_Meta_mkAuxLemma___closed__5; +x_141 = lean_alloc_ctor(0, 6, 0); +lean_ctor_set(x_141, 0, x_139); +lean_ctor_set(x_141, 1, x_134); +lean_ctor_set(x_141, 2, x_135); +lean_ctor_set(x_141, 3, x_136); +lean_ctor_set(x_141, 4, x_140); +lean_ctor_set(x_141, 5, x_137); +x_142 = lean_st_ref_set(x_7, x_141, x_102); x_143 = lean_ctor_get(x_142, 1); lean_inc(x_143); lean_dec(x_142); -x_144 = lean_st_ref_take(x_5, x_143); -x_145 = lean_ctor_get(x_144, 0); +x_144 = lean_st_ref_get(x_7, x_143); +lean_dec(x_7); +x_145 = lean_ctor_get(x_144, 1); lean_inc(x_145); -x_146 = lean_ctor_get(x_144, 1); -lean_inc(x_146); lean_dec(x_144); -x_147 = lean_ctor_get(x_145, 0); +x_146 = lean_st_ref_take(x_5, x_145); +x_147 = lean_ctor_get(x_146, 0); lean_inc(x_147); -x_148 = lean_ctor_get(x_145, 2); +x_148 = lean_ctor_get(x_146, 1); lean_inc(x_148); -x_149 = lean_ctor_get(x_145, 3); +lean_dec(x_146); +x_149 = lean_ctor_get(x_147, 0); lean_inc(x_149); -if (lean_is_exclusive(x_145)) { - lean_ctor_release(x_145, 0); - lean_ctor_release(x_145, 1); - lean_ctor_release(x_145, 2); - lean_ctor_release(x_145, 3); - x_150 = x_145; +x_150 = lean_ctor_get(x_147, 2); +lean_inc(x_150); +x_151 = lean_ctor_get(x_147, 3); +lean_inc(x_151); +if (lean_is_exclusive(x_147)) { + lean_ctor_release(x_147, 0); + lean_ctor_release(x_147, 1); + lean_ctor_release(x_147, 2); + lean_ctor_release(x_147, 3); + x_152 = x_147; } else { - lean_dec_ref(x_145); - x_150 = lean_box(0); + lean_dec_ref(x_147); + x_152 = lean_box(0); } -x_151 = l_Lean_Meta_mkAuxLemma___closed__12; -if (lean_is_scalar(x_150)) { - x_152 = lean_alloc_ctor(0, 4, 0); +x_153 = l_Lean_Meta_mkAuxLemma___closed__12; +if (lean_is_scalar(x_152)) { + x_154 = lean_alloc_ctor(0, 4, 0); } else { - x_152 = x_150; + x_154 = x_152; } -lean_ctor_set(x_152, 0, x_147); -lean_ctor_set(x_152, 1, x_151); -lean_ctor_set(x_152, 2, x_148); -lean_ctor_set(x_152, 3, x_149); -x_153 = lean_st_ref_set(x_5, x_152, x_146); +lean_ctor_set(x_154, 0, x_149); +lean_ctor_set(x_154, 1, x_153); +lean_ctor_set(x_154, 2, x_150); +lean_ctor_set(x_154, 3, x_151); +x_155 = lean_st_ref_set(x_5, x_154, x_148); lean_dec(x_5); -x_154 = lean_ctor_get(x_153, 1); -lean_inc(x_154); -if (lean_is_exclusive(x_153)) { - lean_ctor_release(x_153, 0); - lean_ctor_release(x_153, 1); - x_155 = x_153; +x_156 = lean_ctor_get(x_155, 1); +lean_inc(x_156); +if (lean_is_exclusive(x_155)) { + lean_ctor_release(x_155, 0); + lean_ctor_release(x_155, 1); + x_157 = x_155; } else { - lean_dec_ref(x_153); - x_155 = lean_box(0); + lean_dec_ref(x_155); + x_157 = lean_box(0); } -if (lean_is_scalar(x_155)) { - x_156 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_157)) { + x_158 = lean_alloc_ctor(0, 2, 0); } else { - x_156 = x_155; + x_158 = x_157; } -lean_ctor_set(x_156, 0, x_21); -lean_ctor_set(x_156, 1, x_154); -return x_156; +lean_ctor_set(x_158, 0, x_21); +lean_ctor_set(x_158, 1, x_156); +return x_158; } } else { -uint8_t x_157; +uint8_t x_159; lean_dec(x_21); lean_dec(x_7); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_157 = !lean_is_exclusive(x_96); -if (x_157 == 0) +x_159 = !lean_is_exclusive(x_98); +if (x_159 == 0) { -return x_96; +return x_98; } else { -lean_object* x_158; lean_object* x_159; lean_object* x_160; -x_158 = lean_ctor_get(x_96, 0); -x_159 = lean_ctor_get(x_96, 1); -lean_inc(x_159); -lean_inc(x_158); -lean_dec(x_96); -x_160 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_160, 0, x_158); -lean_ctor_set(x_160, 1, x_159); -return x_160; +lean_object* x_160; lean_object* x_161; lean_object* x_162; +x_160 = lean_ctor_get(x_98, 0); +x_161 = lean_ctor_get(x_98, 1); +lean_inc(x_161); +lean_inc(x_160); +lean_dec(x_98); +x_162 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_162, 0, x_160); +lean_ctor_set(x_162, 1, x_161); +return x_162; } } } else { -lean_dec(x_24); +lean_dec(x_26); lean_dec(x_21); lean_dec(x_7); lean_dec(x_6); @@ -2616,378 +2622,384 @@ lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); -lean_ctor_set(x_9, 0, x_93); +lean_ctor_set(x_9, 0, x_95); return x_9; } } } else { -lean_object* x_161; lean_object* x_162; lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; -x_161 = lean_ctor_get(x_9, 0); -x_162 = lean_ctor_get(x_9, 1); -lean_inc(x_162); -lean_inc(x_161); -lean_dec(x_9); -x_163 = lean_ctor_get(x_161, 0); +lean_object* x_163; lean_object* x_164; lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; lean_object* x_175; lean_object* x_176; lean_object* x_177; lean_object* x_178; lean_object* x_179; lean_object* x_180; +x_163 = lean_ctor_get(x_9, 0); +x_164 = lean_ctor_get(x_9, 1); +lean_inc(x_164); lean_inc(x_163); -lean_dec(x_161); -x_164 = l_Lean_Meta_instInhabitedAuxLemmas; -x_165 = l_Lean_Meta_mkAuxLemma___closed__1; -x_166 = l_Lean_EnvExtensionInterfaceUnsafe_getState___rarg(x_164, x_165, x_163); -x_167 = lean_environment_main_module(x_163); -x_168 = l_Lean_Meta_mkAuxLemma___closed__3; -x_169 = l_Lean_Name_append(x_167, x_168); -lean_dec(x_167); -x_170 = lean_ctor_get(x_166, 0); -lean_inc(x_170); -x_171 = lean_name_mk_numeral(x_169, x_170); +lean_dec(x_9); +x_165 = lean_ctor_get(x_163, 0); +lean_inc(x_165); +lean_dec(x_163); +x_166 = l_Lean_Meta_instInhabitedAuxLemmas; +x_167 = l_Lean_Meta_mkAuxLemma___closed__1; +x_168 = l_Lean_EnvExtensionInterfaceUnsafe_getState___rarg(x_166, x_167, x_165); +x_169 = lean_environment_main_module(x_165); +x_170 = l_Lean_Meta_mkAuxLemma___closed__3; +x_171 = l_Lean_Name_append(x_169, x_170); +lean_dec(x_169); +x_172 = lean_ctor_get(x_168, 0); +lean_inc(x_172); +x_173 = lean_name_mk_numeral(x_171, x_172); lean_inc(x_2); lean_inc(x_1); -lean_inc(x_171); -x_172 = lean_alloc_ctor(0, 3, 0); -lean_ctor_set(x_172, 0, x_171); -lean_ctor_set(x_172, 1, x_1); -lean_ctor_set(x_172, 2, x_2); -x_173 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_173, 0, x_172); -lean_ctor_set(x_173, 1, x_3); -x_174 = lean_alloc_ctor(2, 1, 0); +lean_inc(x_173); +x_174 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_174, 0, x_173); -x_175 = lean_ctor_get(x_166, 1); -lean_inc(x_175); -lean_dec(x_166); +lean_ctor_set(x_174, 1, x_1); +lean_ctor_set(x_174, 2, x_2); +x_175 = lean_box(0); +lean_inc(x_173); +x_176 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_176, 0, x_173); +lean_ctor_set(x_176, 1, x_175); +x_177 = lean_alloc_ctor(0, 3, 0); +lean_ctor_set(x_177, 0, x_174); +lean_ctor_set(x_177, 1, x_3); +lean_ctor_set(x_177, 2, x_176); +x_178 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_178, 0, x_177); +x_179 = lean_ctor_get(x_168, 1); +lean_inc(x_179); +lean_dec(x_168); lean_inc(x_2); -x_176 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_mkAuxLemma___spec__1(x_175, x_2); -if (lean_obj_tag(x_176) == 0) +x_180 = l_Std_PersistentHashMap_find_x3f___at_Lean_Meta_mkAuxLemma___spec__1(x_179, x_2); +if (lean_obj_tag(x_180) == 0) { -lean_object* x_177; +lean_object* x_181; lean_inc(x_7); lean_inc(x_5); -x_177 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_174, x_4, x_5, x_6, x_7, x_162); -if (lean_obj_tag(x_177) == 0) +x_181 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_178, x_4, x_5, x_6, x_7, x_164); +if (lean_obj_tag(x_181) == 0) { -lean_object* x_178; lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; lean_object* x_208; -x_178 = lean_ctor_get(x_177, 1); -lean_inc(x_178); -lean_dec(x_177); -x_179 = lean_st_ref_take(x_7, x_178); -x_180 = lean_ctor_get(x_179, 0); -lean_inc(x_180); -x_181 = lean_ctor_get(x_179, 1); -lean_inc(x_181); -lean_dec(x_179); -x_182 = lean_ctor_get(x_180, 0); +lean_object* x_182; lean_object* x_183; lean_object* x_184; lean_object* x_185; lean_object* x_186; lean_object* x_187; lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; lean_object* x_196; lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; lean_object* x_203; lean_object* x_204; 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_182 = lean_ctor_get(x_181, 1); lean_inc(x_182); -x_183 = lean_ctor_get(x_180, 1); -lean_inc(x_183); -x_184 = lean_ctor_get(x_180, 2); +lean_dec(x_181); +x_183 = lean_st_ref_take(x_7, x_182); +x_184 = lean_ctor_get(x_183, 0); lean_inc(x_184); -x_185 = lean_ctor_get(x_180, 3); +x_185 = lean_ctor_get(x_183, 1); lean_inc(x_185); -x_186 = lean_ctor_get(x_180, 5); +lean_dec(x_183); +x_186 = lean_ctor_get(x_184, 0); lean_inc(x_186); -if (lean_is_exclusive(x_180)) { - lean_ctor_release(x_180, 0); - lean_ctor_release(x_180, 1); - lean_ctor_release(x_180, 2); - lean_ctor_release(x_180, 3); - lean_ctor_release(x_180, 4); - lean_ctor_release(x_180, 5); - x_187 = x_180; +x_187 = lean_ctor_get(x_184, 1); +lean_inc(x_187); +x_188 = lean_ctor_get(x_184, 2); +lean_inc(x_188); +x_189 = lean_ctor_get(x_184, 3); +lean_inc(x_189); +x_190 = lean_ctor_get(x_184, 5); +lean_inc(x_190); +if (lean_is_exclusive(x_184)) { + lean_ctor_release(x_184, 0); + lean_ctor_release(x_184, 1); + lean_ctor_release(x_184, 2); + lean_ctor_release(x_184, 3); + lean_ctor_release(x_184, 4); + lean_ctor_release(x_184, 5); + x_191 = x_184; } else { - lean_dec_ref(x_180); - x_187 = lean_box(0); + lean_dec_ref(x_184); + x_191 = lean_box(0); } -lean_inc(x_171); -x_188 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); -lean_closure_set(x_188, 0, x_171); -lean_closure_set(x_188, 1, x_1); -lean_closure_set(x_188, 2, x_2); -x_189 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_165, x_182, x_188); -x_190 = l_Lean_Meta_mkAuxLemma___closed__5; -if (lean_is_scalar(x_187)) { - x_191 = lean_alloc_ctor(0, 6, 0); +lean_inc(x_173); +x_192 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); +lean_closure_set(x_192, 0, x_173); +lean_closure_set(x_192, 1, x_1); +lean_closure_set(x_192, 2, x_2); +x_193 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_167, x_186, x_192); +x_194 = l_Lean_Meta_mkAuxLemma___closed__5; +if (lean_is_scalar(x_191)) { + x_195 = lean_alloc_ctor(0, 6, 0); } else { - x_191 = x_187; + x_195 = x_191; } -lean_ctor_set(x_191, 0, x_189); -lean_ctor_set(x_191, 1, x_183); -lean_ctor_set(x_191, 2, x_184); -lean_ctor_set(x_191, 3, x_185); -lean_ctor_set(x_191, 4, x_190); -lean_ctor_set(x_191, 5, x_186); -x_192 = lean_st_ref_set(x_7, x_191, x_181); -x_193 = lean_ctor_get(x_192, 1); -lean_inc(x_193); -lean_dec(x_192); -x_194 = lean_st_ref_get(x_7, x_193); -lean_dec(x_7); -x_195 = lean_ctor_get(x_194, 1); -lean_inc(x_195); -lean_dec(x_194); -x_196 = lean_st_ref_take(x_5, x_195); -x_197 = lean_ctor_get(x_196, 0); +lean_ctor_set(x_195, 0, x_193); +lean_ctor_set(x_195, 1, x_187); +lean_ctor_set(x_195, 2, x_188); +lean_ctor_set(x_195, 3, x_189); +lean_ctor_set(x_195, 4, x_194); +lean_ctor_set(x_195, 5, x_190); +x_196 = lean_st_ref_set(x_7, x_195, x_185); +x_197 = lean_ctor_get(x_196, 1); lean_inc(x_197); -x_198 = lean_ctor_get(x_196, 1); -lean_inc(x_198); lean_dec(x_196); -x_199 = lean_ctor_get(x_197, 0); -lean_inc(x_199); -x_200 = lean_ctor_get(x_197, 2); -lean_inc(x_200); -x_201 = lean_ctor_get(x_197, 3); -lean_inc(x_201); -if (lean_is_exclusive(x_197)) { - lean_ctor_release(x_197, 0); - lean_ctor_release(x_197, 1); - lean_ctor_release(x_197, 2); - lean_ctor_release(x_197, 3); - x_202 = x_197; -} else { - lean_dec_ref(x_197); - x_202 = lean_box(0); -} -x_203 = l_Lean_Meta_mkAuxLemma___closed__12; -if (lean_is_scalar(x_202)) { - x_204 = lean_alloc_ctor(0, 4, 0); -} else { - x_204 = x_202; -} -lean_ctor_set(x_204, 0, x_199); -lean_ctor_set(x_204, 1, x_203); -lean_ctor_set(x_204, 2, x_200); -lean_ctor_set(x_204, 3, x_201); -x_205 = lean_st_ref_set(x_5, x_204, x_198); -lean_dec(x_5); -x_206 = lean_ctor_get(x_205, 1); -lean_inc(x_206); -if (lean_is_exclusive(x_205)) { - lean_ctor_release(x_205, 0); - lean_ctor_release(x_205, 1); - x_207 = x_205; -} else { - lean_dec_ref(x_205); - x_207 = lean_box(0); -} -if (lean_is_scalar(x_207)) { - x_208 = lean_alloc_ctor(0, 2, 0); -} else { - x_208 = x_207; -} -lean_ctor_set(x_208, 0, x_171); -lean_ctor_set(x_208, 1, x_206); -return x_208; -} -else -{ -lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; -lean_dec(x_171); +x_198 = lean_st_ref_get(x_7, x_197); lean_dec(x_7); -lean_dec(x_5); -lean_dec(x_2); -lean_dec(x_1); -x_209 = lean_ctor_get(x_177, 0); -lean_inc(x_209); -x_210 = lean_ctor_get(x_177, 1); -lean_inc(x_210); -if (lean_is_exclusive(x_177)) { - lean_ctor_release(x_177, 0); - lean_ctor_release(x_177, 1); - x_211 = x_177; +x_199 = lean_ctor_get(x_198, 1); +lean_inc(x_199); +lean_dec(x_198); +x_200 = lean_st_ref_take(x_5, x_199); +x_201 = lean_ctor_get(x_200, 0); +lean_inc(x_201); +x_202 = lean_ctor_get(x_200, 1); +lean_inc(x_202); +lean_dec(x_200); +x_203 = lean_ctor_get(x_201, 0); +lean_inc(x_203); +x_204 = lean_ctor_get(x_201, 2); +lean_inc(x_204); +x_205 = lean_ctor_get(x_201, 3); +lean_inc(x_205); +if (lean_is_exclusive(x_201)) { + lean_ctor_release(x_201, 0); + lean_ctor_release(x_201, 1); + lean_ctor_release(x_201, 2); + lean_ctor_release(x_201, 3); + x_206 = x_201; } else { - lean_dec_ref(x_177); + lean_dec_ref(x_201); + x_206 = lean_box(0); +} +x_207 = l_Lean_Meta_mkAuxLemma___closed__12; +if (lean_is_scalar(x_206)) { + x_208 = lean_alloc_ctor(0, 4, 0); +} else { + x_208 = x_206; +} +lean_ctor_set(x_208, 0, x_203); +lean_ctor_set(x_208, 1, x_207); +lean_ctor_set(x_208, 2, x_204); +lean_ctor_set(x_208, 3, x_205); +x_209 = lean_st_ref_set(x_5, x_208, x_202); +lean_dec(x_5); +x_210 = lean_ctor_get(x_209, 1); +lean_inc(x_210); +if (lean_is_exclusive(x_209)) { + lean_ctor_release(x_209, 0); + lean_ctor_release(x_209, 1); + x_211 = x_209; +} else { + lean_dec_ref(x_209); x_211 = lean_box(0); } if (lean_is_scalar(x_211)) { - x_212 = lean_alloc_ctor(1, 2, 0); + x_212 = lean_alloc_ctor(0, 2, 0); } else { x_212 = x_211; } -lean_ctor_set(x_212, 0, x_209); +lean_ctor_set(x_212, 0, x_173); lean_ctor_set(x_212, 1, x_210); return x_212; } -} else { -lean_object* x_213; lean_object* x_214; lean_object* x_215; uint8_t x_216; -x_213 = lean_ctor_get(x_176, 0); -lean_inc(x_213); -lean_dec(x_176); -x_214 = lean_ctor_get(x_213, 0); -lean_inc(x_214); -x_215 = lean_ctor_get(x_213, 1); -lean_inc(x_215); -lean_dec(x_213); -x_216 = l_List_beq___at_Lean_OpenDecl_instToStringOpenDecl___spec__1(x_1, x_215); -lean_dec(x_215); -if (x_216 == 0) -{ -lean_object* x_217; -lean_dec(x_214); -lean_inc(x_7); -lean_inc(x_5); -x_217 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_174, x_4, x_5, x_6, x_7, x_162); -if (lean_obj_tag(x_217) == 0) -{ -lean_object* x_218; lean_object* x_219; lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; -x_218 = lean_ctor_get(x_217, 1); -lean_inc(x_218); -lean_dec(x_217); -x_219 = lean_st_ref_take(x_7, x_218); -x_220 = lean_ctor_get(x_219, 0); -lean_inc(x_220); -x_221 = lean_ctor_get(x_219, 1); -lean_inc(x_221); -lean_dec(x_219); -x_222 = lean_ctor_get(x_220, 0); -lean_inc(x_222); -x_223 = lean_ctor_get(x_220, 1); -lean_inc(x_223); -x_224 = lean_ctor_get(x_220, 2); -lean_inc(x_224); -x_225 = lean_ctor_get(x_220, 3); -lean_inc(x_225); -x_226 = lean_ctor_get(x_220, 5); -lean_inc(x_226); -if (lean_is_exclusive(x_220)) { - lean_ctor_release(x_220, 0); - lean_ctor_release(x_220, 1); - lean_ctor_release(x_220, 2); - lean_ctor_release(x_220, 3); - lean_ctor_release(x_220, 4); - lean_ctor_release(x_220, 5); - x_227 = x_220; -} else { - lean_dec_ref(x_220); - x_227 = lean_box(0); -} -lean_inc(x_171); -x_228 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); -lean_closure_set(x_228, 0, x_171); -lean_closure_set(x_228, 1, x_1); -lean_closure_set(x_228, 2, x_2); -x_229 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_165, x_222, x_228); -x_230 = l_Lean_Meta_mkAuxLemma___closed__5; -if (lean_is_scalar(x_227)) { - x_231 = lean_alloc_ctor(0, 6, 0); -} else { - x_231 = x_227; -} -lean_ctor_set(x_231, 0, x_229); -lean_ctor_set(x_231, 1, x_223); -lean_ctor_set(x_231, 2, x_224); -lean_ctor_set(x_231, 3, x_225); -lean_ctor_set(x_231, 4, x_230); -lean_ctor_set(x_231, 5, x_226); -x_232 = lean_st_ref_set(x_7, x_231, x_221); -x_233 = lean_ctor_get(x_232, 1); -lean_inc(x_233); -lean_dec(x_232); -x_234 = lean_st_ref_get(x_7, x_233); -lean_dec(x_7); -x_235 = lean_ctor_get(x_234, 1); -lean_inc(x_235); -lean_dec(x_234); -x_236 = lean_st_ref_take(x_5, x_235); -x_237 = lean_ctor_get(x_236, 0); -lean_inc(x_237); -x_238 = lean_ctor_get(x_236, 1); -lean_inc(x_238); -lean_dec(x_236); -x_239 = lean_ctor_get(x_237, 0); -lean_inc(x_239); -x_240 = lean_ctor_get(x_237, 2); -lean_inc(x_240); -x_241 = lean_ctor_get(x_237, 3); -lean_inc(x_241); -if (lean_is_exclusive(x_237)) { - lean_ctor_release(x_237, 0); - lean_ctor_release(x_237, 1); - lean_ctor_release(x_237, 2); - lean_ctor_release(x_237, 3); - x_242 = x_237; -} else { - lean_dec_ref(x_237); - x_242 = lean_box(0); -} -x_243 = l_Lean_Meta_mkAuxLemma___closed__12; -if (lean_is_scalar(x_242)) { - x_244 = lean_alloc_ctor(0, 4, 0); -} else { - x_244 = x_242; -} -lean_ctor_set(x_244, 0, x_239); -lean_ctor_set(x_244, 1, x_243); -lean_ctor_set(x_244, 2, x_240); -lean_ctor_set(x_244, 3, x_241); -x_245 = lean_st_ref_set(x_5, x_244, x_238); -lean_dec(x_5); -x_246 = lean_ctor_get(x_245, 1); -lean_inc(x_246); -if (lean_is_exclusive(x_245)) { - lean_ctor_release(x_245, 0); - lean_ctor_release(x_245, 1); - x_247 = x_245; -} else { - lean_dec_ref(x_245); - x_247 = lean_box(0); -} -if (lean_is_scalar(x_247)) { - x_248 = lean_alloc_ctor(0, 2, 0); -} else { - x_248 = x_247; -} -lean_ctor_set(x_248, 0, x_171); -lean_ctor_set(x_248, 1, x_246); -return x_248; -} -else -{ -lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; -lean_dec(x_171); +lean_object* x_213; lean_object* x_214; lean_object* x_215; lean_object* x_216; +lean_dec(x_173); lean_dec(x_7); lean_dec(x_5); lean_dec(x_2); lean_dec(x_1); -x_249 = lean_ctor_get(x_217, 0); -lean_inc(x_249); -x_250 = lean_ctor_get(x_217, 1); -lean_inc(x_250); -if (lean_is_exclusive(x_217)) { - lean_ctor_release(x_217, 0); - lean_ctor_release(x_217, 1); - x_251 = x_217; +x_213 = lean_ctor_get(x_181, 0); +lean_inc(x_213); +x_214 = lean_ctor_get(x_181, 1); +lean_inc(x_214); +if (lean_is_exclusive(x_181)) { + lean_ctor_release(x_181, 0); + lean_ctor_release(x_181, 1); + x_215 = x_181; } else { - lean_dec_ref(x_217); - x_251 = lean_box(0); + lean_dec_ref(x_181); + x_215 = lean_box(0); } -if (lean_is_scalar(x_251)) { - x_252 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_215)) { + x_216 = lean_alloc_ctor(1, 2, 0); } else { - x_252 = x_251; + x_216 = x_215; } -lean_ctor_set(x_252, 0, x_249); -lean_ctor_set(x_252, 1, x_250); -return x_252; +lean_ctor_set(x_216, 0, x_213); +lean_ctor_set(x_216, 1, x_214); +return x_216; } } else { -lean_object* x_253; -lean_dec(x_174); -lean_dec(x_171); +lean_object* x_217; lean_object* x_218; lean_object* x_219; uint8_t x_220; +x_217 = lean_ctor_get(x_180, 0); +lean_inc(x_217); +lean_dec(x_180); +x_218 = lean_ctor_get(x_217, 0); +lean_inc(x_218); +x_219 = lean_ctor_get(x_217, 1); +lean_inc(x_219); +lean_dec(x_217); +x_220 = l_List_beq___at_Lean_OpenDecl_instToStringOpenDecl___spec__1(x_1, x_219); +lean_dec(x_219); +if (x_220 == 0) +{ +lean_object* x_221; +lean_dec(x_218); +lean_inc(x_7); +lean_inc(x_5); +x_221 = l_Lean_addDecl___at_Lean_Meta_mkAuxLemma___spec__4(x_178, x_4, x_5, x_6, x_7, x_164); +if (lean_obj_tag(x_221) == 0) +{ +lean_object* x_222; lean_object* x_223; lean_object* x_224; lean_object* x_225; lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; lean_object* x_230; lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; lean_object* x_241; lean_object* x_242; lean_object* x_243; lean_object* x_244; lean_object* x_245; lean_object* x_246; lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; lean_object* x_251; lean_object* x_252; +x_222 = lean_ctor_get(x_221, 1); +lean_inc(x_222); +lean_dec(x_221); +x_223 = lean_st_ref_take(x_7, x_222); +x_224 = lean_ctor_get(x_223, 0); +lean_inc(x_224); +x_225 = lean_ctor_get(x_223, 1); +lean_inc(x_225); +lean_dec(x_223); +x_226 = lean_ctor_get(x_224, 0); +lean_inc(x_226); +x_227 = lean_ctor_get(x_224, 1); +lean_inc(x_227); +x_228 = lean_ctor_get(x_224, 2); +lean_inc(x_228); +x_229 = lean_ctor_get(x_224, 3); +lean_inc(x_229); +x_230 = lean_ctor_get(x_224, 5); +lean_inc(x_230); +if (lean_is_exclusive(x_224)) { + lean_ctor_release(x_224, 0); + lean_ctor_release(x_224, 1); + lean_ctor_release(x_224, 2); + lean_ctor_release(x_224, 3); + lean_ctor_release(x_224, 4); + lean_ctor_release(x_224, 5); + x_231 = x_224; +} else { + lean_dec_ref(x_224); + x_231 = lean_box(0); +} +lean_inc(x_173); +x_232 = lean_alloc_closure((void*)(l_Lean_Meta_mkAuxLemma___lambda__1), 4, 3); +lean_closure_set(x_232, 0, x_173); +lean_closure_set(x_232, 1, x_1); +lean_closure_set(x_232, 2, x_2); +x_233 = l_Lean_EnvExtensionInterfaceUnsafe_imp___elambda__2___rarg(x_167, x_226, x_232); +x_234 = l_Lean_Meta_mkAuxLemma___closed__5; +if (lean_is_scalar(x_231)) { + x_235 = lean_alloc_ctor(0, 6, 0); +} else { + x_235 = x_231; +} +lean_ctor_set(x_235, 0, x_233); +lean_ctor_set(x_235, 1, x_227); +lean_ctor_set(x_235, 2, x_228); +lean_ctor_set(x_235, 3, x_229); +lean_ctor_set(x_235, 4, x_234); +lean_ctor_set(x_235, 5, x_230); +x_236 = lean_st_ref_set(x_7, x_235, x_225); +x_237 = lean_ctor_get(x_236, 1); +lean_inc(x_237); +lean_dec(x_236); +x_238 = lean_st_ref_get(x_7, x_237); +lean_dec(x_7); +x_239 = lean_ctor_get(x_238, 1); +lean_inc(x_239); +lean_dec(x_238); +x_240 = lean_st_ref_take(x_5, x_239); +x_241 = lean_ctor_get(x_240, 0); +lean_inc(x_241); +x_242 = lean_ctor_get(x_240, 1); +lean_inc(x_242); +lean_dec(x_240); +x_243 = lean_ctor_get(x_241, 0); +lean_inc(x_243); +x_244 = lean_ctor_get(x_241, 2); +lean_inc(x_244); +x_245 = lean_ctor_get(x_241, 3); +lean_inc(x_245); +if (lean_is_exclusive(x_241)) { + lean_ctor_release(x_241, 0); + lean_ctor_release(x_241, 1); + lean_ctor_release(x_241, 2); + lean_ctor_release(x_241, 3); + x_246 = x_241; +} else { + lean_dec_ref(x_241); + x_246 = lean_box(0); +} +x_247 = l_Lean_Meta_mkAuxLemma___closed__12; +if (lean_is_scalar(x_246)) { + x_248 = lean_alloc_ctor(0, 4, 0); +} else { + x_248 = x_246; +} +lean_ctor_set(x_248, 0, x_243); +lean_ctor_set(x_248, 1, x_247); +lean_ctor_set(x_248, 2, x_244); +lean_ctor_set(x_248, 3, x_245); +x_249 = lean_st_ref_set(x_5, x_248, x_242); +lean_dec(x_5); +x_250 = lean_ctor_get(x_249, 1); +lean_inc(x_250); +if (lean_is_exclusive(x_249)) { + lean_ctor_release(x_249, 0); + lean_ctor_release(x_249, 1); + x_251 = x_249; +} else { + lean_dec_ref(x_249); + x_251 = lean_box(0); +} +if (lean_is_scalar(x_251)) { + x_252 = lean_alloc_ctor(0, 2, 0); +} else { + x_252 = x_251; +} +lean_ctor_set(x_252, 0, x_173); +lean_ctor_set(x_252, 1, x_250); +return x_252; +} +else +{ +lean_object* x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; +lean_dec(x_173); +lean_dec(x_7); +lean_dec(x_5); +lean_dec(x_2); +lean_dec(x_1); +x_253 = lean_ctor_get(x_221, 0); +lean_inc(x_253); +x_254 = lean_ctor_get(x_221, 1); +lean_inc(x_254); +if (lean_is_exclusive(x_221)) { + lean_ctor_release(x_221, 0); + lean_ctor_release(x_221, 1); + x_255 = x_221; +} else { + lean_dec_ref(x_221); + x_255 = lean_box(0); +} +if (lean_is_scalar(x_255)) { + x_256 = lean_alloc_ctor(1, 2, 0); +} else { + x_256 = x_255; +} +lean_ctor_set(x_256, 0, x_253); +lean_ctor_set(x_256, 1, x_254); +return x_256; +} +} +else +{ +lean_object* x_257; +lean_dec(x_178); +lean_dec(x_173); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); -x_253 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_253, 0, x_214); -lean_ctor_set(x_253, 1, x_162); -return x_253; +x_257 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_257, 0, x_218); +lean_ctor_set(x_257, 1, x_164); +return x_257; } } } diff --git a/stage0/stdlib/Lean/ParserCompiler.c b/stage0/stdlib/Lean/ParserCompiler.c index 445f40a4d9..54ff0a4d64 100644 --- a/stage0/stdlib/Lean/ParserCompiler.c +++ b/stage0/stdlib/Lean/ParserCompiler.c @@ -15965,7 +15965,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -15977,29 +15977,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -16009,113 +16014,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__4(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__4(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -16130,29 +16135,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -16166,23 +16171,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -16726,7 +16731,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -16738,29 +16743,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -16770,113 +16780,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__10(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__10(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -16891,29 +16901,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -16927,23 +16937,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -17487,7 +17497,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -17499,29 +17509,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -17531,113 +17546,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__16(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__16(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -17652,29 +17667,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -17688,23 +17703,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -18248,7 +18263,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -18260,29 +18275,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -18292,113 +18312,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__22(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__22(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -18413,29 +18433,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -18449,23 +18469,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -19009,7 +19029,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -19021,29 +19041,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -19053,113 +19078,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__28(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__28(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -19174,29 +19199,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -19210,23 +19235,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -19826,7 +19851,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -19838,29 +19863,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -19870,113 +19900,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__35(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__35(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -19991,29 +20021,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -20027,23 +20057,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -20587,7 +20617,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -20599,29 +20629,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -20631,113 +20666,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__41(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__41(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -20752,29 +20787,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -20788,23 +20823,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -21348,7 +21383,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -21360,29 +21395,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -21392,113 +21432,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__47(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__47(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -21513,29 +21553,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -21549,23 +21589,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -22109,7 +22149,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -22121,29 +22161,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -22153,113 +22198,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__53(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__53(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -22274,29 +22319,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -22310,23 +22355,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } @@ -22870,7 +22915,7 @@ lean_inc(x_5); x_24 = l_Lean_Meta_forallTelescope___at___private_Lean_Meta_InferType_0__Lean_Meta_inferForallType___spec__2___rarg(x_5, x_23, x_14, x_15, x_16, x_17, x_22); if (lean_obj_tag(x_24) == 0) { -lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; uint8_t x_30; lean_object* x_31; 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_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; x_25 = lean_ctor_get(x_24, 0); lean_inc(x_25); x_26 = lean_ctor_get(x_24, 1); @@ -22882,29 +22927,34 @@ x_28 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_28, 0, x_6); lean_ctor_set(x_28, 1, x_27); lean_ctor_set(x_28, 2, x_25); -x_29 = lean_box(0); -x_30 = 1; -x_31 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_31, 0, x_28); -lean_ctor_set(x_31, 1, x_21); -lean_ctor_set(x_31, 2, x_29); -lean_ctor_set_uint8(x_31, sizeof(void*)*3, x_30); -x_32 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_32, 0, x_31); -x_33 = lean_st_ref_get(x_17, x_26); -x_34 = lean_ctor_get(x_33, 0); -lean_inc(x_34); -x_35 = lean_ctor_get(x_33, 1); +lean_inc(x_6); +x_29 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_29, 0, x_6); +lean_ctor_set(x_29, 1, x_27); +x_30 = lean_box(0); +x_31 = 1; +x_32 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_32, 0, x_28); +lean_ctor_set(x_32, 1, x_21); +lean_ctor_set(x_32, 2, x_30); +lean_ctor_set(x_32, 3, x_29); +lean_ctor_set_uint8(x_32, sizeof(void*)*4, x_31); +x_33 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_33, 0, x_32); +x_34 = lean_st_ref_get(x_17, x_26); +x_35 = lean_ctor_get(x_34, 0); lean_inc(x_35); -lean_dec(x_33); -x_36 = lean_ctor_get(x_34, 0); +x_36 = lean_ctor_get(x_34, 1); lean_inc(x_36); lean_dec(x_34); -x_37 = l_Lean_Environment_addAndCompile(x_36, x_27, x_32); -lean_dec(x_32); -if (lean_obj_tag(x_37) == 0) +x_37 = lean_ctor_get(x_35, 0); +lean_inc(x_37); +lean_dec(x_35); +x_38 = l_Lean_Environment_addAndCompile(x_37, x_27, x_33); +lean_dec(x_33); +if (lean_obj_tag(x_38) == 0) { -lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; +lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; lean_object* x_43; lean_object* x_44; lean_dec(x_12); lean_dec(x_11); lean_dec(x_10); @@ -22914,113 +22964,113 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_38 = lean_ctor_get(x_37, 0); -lean_inc(x_38); -lean_dec(x_37); -x_39 = l_Lean_KernelException_toMessageData(x_38, x_27); -x_40 = lean_st_ref_get(x_17, x_35); -x_41 = lean_ctor_get(x_40, 1); -lean_inc(x_41); -lean_dec(x_40); -x_42 = lean_ctor_get(x_16, 5); +x_39 = lean_ctor_get(x_38, 0); +lean_inc(x_39); +lean_dec(x_38); +x_40 = l_Lean_KernelException_toMessageData(x_39, x_27); +x_41 = lean_st_ref_get(x_17, x_36); +x_42 = lean_ctor_get(x_41, 1); lean_inc(x_42); -x_43 = l_Lean_MessageData_toString(x_39, x_41); -if (lean_obj_tag(x_43) == 0) +lean_dec(x_41); +x_43 = lean_ctor_get(x_16, 5); +lean_inc(x_43); +x_44 = l_Lean_MessageData_toString(x_40, x_42); +if (lean_obj_tag(x_44) == 0) { -lean_object* x_44; lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; uint8_t x_49; -lean_dec(x_42); -x_44 = lean_ctor_get(x_43, 0); -lean_inc(x_44); -x_45 = lean_ctor_get(x_43, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; lean_object* x_48; lean_object* x_49; uint8_t x_50; +lean_dec(x_43); +x_45 = lean_ctor_get(x_44, 0); lean_inc(x_45); -lean_dec(x_43); -x_46 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_46, 0, x_44); -x_47 = lean_alloc_ctor(0, 1, 0); -lean_ctor_set(x_47, 0, x_46); -x_48 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_47, x_14, x_15, x_16, x_17, x_45); +x_46 = lean_ctor_get(x_44, 1); +lean_inc(x_46); +lean_dec(x_44); +x_47 = lean_alloc_ctor(2, 1, 0); +lean_ctor_set(x_47, 0, x_45); +x_48 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_48, 0, x_47); +x_49 = l_Lean_throwError___at_Lean_ParserCompiler_compileParserExpr___spec__5(x_48, x_14, x_15, x_16, x_17, x_46); lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_49 = !lean_is_exclusive(x_48); -if (x_49 == 0) +x_50 = !lean_is_exclusive(x_49); +if (x_50 == 0) { -return x_48; +return x_49; } else { -lean_object* x_50; lean_object* x_51; lean_object* x_52; -x_50 = lean_ctor_get(x_48, 0); -x_51 = lean_ctor_get(x_48, 1); +lean_object* x_51; lean_object* x_52; lean_object* x_53; +x_51 = lean_ctor_get(x_49, 0); +x_52 = lean_ctor_get(x_49, 1); +lean_inc(x_52); lean_inc(x_51); -lean_inc(x_50); -lean_dec(x_48); -x_52 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_52, 0, x_50); -lean_ctor_set(x_52, 1, x_51); -return x_52; +lean_dec(x_49); +x_53 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_53, 0, x_51); +lean_ctor_set(x_53, 1, x_52); +return x_53; } } else { -uint8_t x_53; +uint8_t x_54; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); lean_dec(x_14); -x_53 = !lean_is_exclusive(x_43); -if (x_53 == 0) +x_54 = !lean_is_exclusive(x_44); +if (x_54 == 0) { -lean_object* x_54; lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; -x_54 = lean_ctor_get(x_43, 0); -x_55 = lean_io_error_to_string(x_54); -x_56 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_56, 0, x_55); -x_57 = lean_alloc_ctor(0, 1, 0); +lean_object* x_55; lean_object* x_56; lean_object* x_57; lean_object* x_58; lean_object* x_59; +x_55 = lean_ctor_get(x_44, 0); +x_56 = lean_io_error_to_string(x_55); +x_57 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_57, 0, x_56); -x_58 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_58, 0, x_42); -lean_ctor_set(x_58, 1, x_57); -lean_ctor_set(x_43, 0, x_58); -return x_43; +x_58 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_58, 0, x_57); +x_59 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_59, 0, x_43); +lean_ctor_set(x_59, 1, x_58); +lean_ctor_set(x_44, 0, x_59); +return x_44; } else { -lean_object* x_59; lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; -x_59 = lean_ctor_get(x_43, 0); -x_60 = lean_ctor_get(x_43, 1); +lean_object* x_60; lean_object* x_61; lean_object* x_62; lean_object* x_63; lean_object* x_64; lean_object* x_65; lean_object* x_66; +x_60 = lean_ctor_get(x_44, 0); +x_61 = lean_ctor_get(x_44, 1); +lean_inc(x_61); lean_inc(x_60); -lean_inc(x_59); -lean_dec(x_43); -x_61 = lean_io_error_to_string(x_59); -x_62 = lean_alloc_ctor(2, 1, 0); -lean_ctor_set(x_62, 0, x_61); -x_63 = lean_alloc_ctor(0, 1, 0); +lean_dec(x_44); +x_62 = lean_io_error_to_string(x_60); +x_63 = lean_alloc_ctor(2, 1, 0); lean_ctor_set(x_63, 0, x_62); -x_64 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_64, 0, x_42); -lean_ctor_set(x_64, 1, x_63); -x_65 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_65, 0, x_64); -lean_ctor_set(x_65, 1, x_60); -return x_65; +x_64 = lean_alloc_ctor(0, 1, 0); +lean_ctor_set(x_64, 0, x_63); +x_65 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_65, 0, x_43); +lean_ctor_set(x_65, 1, x_64); +x_66 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_66, 0, x_65); +lean_ctor_set(x_66, 1, x_61); +return x_66; } } } else { -lean_object* x_66; lean_object* x_67; -x_66 = lean_ctor_get(x_37, 0); -lean_inc(x_66); -lean_dec(x_37); -x_67 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__59(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_66, x_14, x_15, x_16, x_17, x_35); -return x_67; +lean_object* x_67; lean_object* x_68; +x_67 = lean_ctor_get(x_38, 0); +lean_inc(x_67); +lean_dec(x_38); +x_68 = l_Lean_ParserCompiler_compileParserExpr___rarg___lambda__59(x_7, x_8, x_6, x_27, x_9, x_1, x_3, x_4, x_5, x_10, x_11, x_12, x_67, x_14, x_15, x_16, x_17, x_36); +return x_68; } } else { -uint8_t x_68; +uint8_t x_69; lean_dec(x_21); lean_dec(x_17); lean_dec(x_16); @@ -23035,29 +23085,29 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_68 = !lean_is_exclusive(x_24); -if (x_68 == 0) +x_69 = !lean_is_exclusive(x_24); +if (x_69 == 0) { return x_24; } else { -lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_69 = lean_ctor_get(x_24, 0); -x_70 = lean_ctor_get(x_24, 1); +lean_object* x_70; lean_object* x_71; lean_object* x_72; +x_70 = lean_ctor_get(x_24, 0); +x_71 = lean_ctor_get(x_24, 1); +lean_inc(x_71); lean_inc(x_70); -lean_inc(x_69); lean_dec(x_24); -x_71 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_71, 0, x_69); -lean_ctor_set(x_71, 1, x_70); -return x_71; +x_72 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_72, 0, x_70); +lean_ctor_set(x_72, 1, x_71); +return x_72; } } } else { -uint8_t x_72; +uint8_t x_73; lean_dec(x_17); lean_dec(x_16); lean_dec(x_15); @@ -23071,23 +23121,23 @@ lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_1); -x_72 = !lean_is_exclusive(x_20); -if (x_72 == 0) +x_73 = !lean_is_exclusive(x_20); +if (x_73 == 0) { return x_20; } else { -lean_object* x_73; lean_object* x_74; lean_object* x_75; -x_73 = lean_ctor_get(x_20, 0); -x_74 = lean_ctor_get(x_20, 1); +lean_object* x_74; lean_object* x_75; lean_object* x_76; +x_74 = lean_ctor_get(x_20, 0); +x_75 = lean_ctor_get(x_20, 1); +lean_inc(x_75); lean_inc(x_74); -lean_inc(x_73); lean_dec(x_20); -x_75 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_75, 0, x_73); -lean_ctor_set(x_75, 1, x_74); -return x_75; +x_76 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_76, 0, x_74); +lean_ctor_set(x_76, 1, x_75); +return x_76; } } } diff --git a/stage0/stdlib/Lean/Server/Rpc/RequestHandling.c b/stage0/stdlib/Lean/Server/Rpc/RequestHandling.c index 46a715a742..83648606b7 100644 --- a/stage0/stdlib/Lean/Server/Rpc/RequestHandling.c +++ b/stage0/stdlib/Lean/Server/Rpc/RequestHandling.c @@ -6435,7 +6435,7 @@ lean_inc(x_16); x_21 = l_Lean_Elab_Term_TermElabM_run___rarg(x_11, x_18, x_19, x_20, x_16, x_3, x_4, x_17); if (lean_obj_tag(x_21) == 0) { -lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; uint8_t x_31; lean_object* x_32; lean_object* x_33; lean_object* x_34; +lean_object* x_22; lean_object* x_23; lean_object* x_24; lean_object* x_25; lean_object* x_26; lean_object* x_27; lean_object* x_28; lean_object* x_29; lean_object* x_30; lean_object* x_31; uint8_t x_32; lean_object* x_33; lean_object* x_34; lean_object* x_35; x_22 = lean_ctor_get(x_21, 0); lean_inc(x_22); x_23 = lean_ctor_get(x_21, 1); @@ -6458,92 +6458,97 @@ x_29 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_29, 0, x_7); lean_ctor_set(x_29, 1, x_8); lean_ctor_set(x_29, 2, x_9); -x_30 = lean_box(0); -x_31 = 1; -x_32 = lean_alloc_ctor(0, 3, 1); -lean_ctor_set(x_32, 0, x_29); -lean_ctor_set(x_32, 1, x_24); -lean_ctor_set(x_32, 2, x_30); -lean_ctor_set_uint8(x_32, sizeof(void*)*3, x_31); -x_33 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_33, 0, x_32); +lean_inc(x_7); +x_30 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_30, 0, x_7); +lean_ctor_set(x_30, 1, x_8); +x_31 = lean_box(0); +x_32 = 1; +x_33 = lean_alloc_ctor(0, 4, 1); +lean_ctor_set(x_33, 0, x_29); +lean_ctor_set(x_33, 1, x_24); +lean_ctor_set(x_33, 2, x_31); +lean_ctor_set(x_33, 3, x_30); +lean_ctor_set_uint8(x_33, sizeof(void*)*4, x_32); +x_34 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_34, 0, x_33); lean_inc(x_4); lean_inc(x_3); -x_34 = l_Lean_addAndCompile___at_Lean_Server_registerRpcProcedure___spec__1(x_33, x_3, x_4, x_28); -if (lean_obj_tag(x_34) == 0) +x_35 = l_Lean_addAndCompile___at_Lean_Server_registerRpcProcedure___spec__1(x_34, x_3, x_4, x_28); +if (lean_obj_tag(x_35) == 0) { -lean_object* x_35; lean_object* x_36; lean_object* x_37; lean_object* x_38; lean_object* x_39; lean_object* x_40; lean_object* x_41; lean_object* x_42; -x_35 = lean_ctor_get(x_34, 1); -lean_inc(x_35); -lean_dec(x_34); -x_36 = lean_st_ref_get(x_4, x_35); -x_37 = lean_ctor_get(x_36, 0); -lean_inc(x_37); -x_38 = lean_ctor_get(x_36, 1); +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_36 = lean_ctor_get(x_35, 1); +lean_inc(x_36); +lean_dec(x_35); +x_37 = lean_st_ref_get(x_4, x_36); +x_38 = lean_ctor_get(x_37, 0); lean_inc(x_38); -lean_dec(x_36); -x_39 = lean_ctor_get(x_37, 0); +x_39 = lean_ctor_get(x_37, 1); lean_inc(x_39); lean_dec(x_37); -x_40 = l___private_Lean_Server_Rpc_RequestHandling_0__Lean_Server_handleRpcCallUnsafe___lambda__3___closed__2; -x_41 = l_Lean_MapDeclarationExtension_insert___rarg(x_40, x_39, x_1, x_7); -x_42 = l_Lean_setEnv___at_Lean_Meta_unfoldDeclsFrom___spec__1(x_41, x_3, x_4, x_38); +x_40 = lean_ctor_get(x_38, 0); +lean_inc(x_40); +lean_dec(x_38); +x_41 = l___private_Lean_Server_Rpc_RequestHandling_0__Lean_Server_handleRpcCallUnsafe___lambda__3___closed__2; +x_42 = l_Lean_MapDeclarationExtension_insert___rarg(x_41, x_40, x_1, x_7); +x_43 = l_Lean_setEnv___at_Lean_Meta_unfoldDeclsFrom___spec__1(x_42, x_3, x_4, x_39); lean_dec(x_4); lean_dec(x_3); -return x_42; +return x_43; } else { -uint8_t x_43; +uint8_t x_44; lean_dec(x_7); lean_dec(x_4); lean_dec(x_3); lean_dec(x_1); -x_43 = !lean_is_exclusive(x_34); -if (x_43 == 0) +x_44 = !lean_is_exclusive(x_35); +if (x_44 == 0) { -return x_34; +return x_35; } else { -lean_object* x_44; lean_object* x_45; lean_object* x_46; -x_44 = lean_ctor_get(x_34, 0); -x_45 = lean_ctor_get(x_34, 1); +lean_object* x_45; lean_object* x_46; lean_object* x_47; +x_45 = lean_ctor_get(x_35, 0); +x_46 = lean_ctor_get(x_35, 1); +lean_inc(x_46); lean_inc(x_45); -lean_inc(x_44); -lean_dec(x_34); -x_46 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_46, 0, x_44); -lean_ctor_set(x_46, 1, x_45); -return x_46; +lean_dec(x_35); +x_47 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_47, 0, x_45); +lean_ctor_set(x_47, 1, x_46); +return x_47; } } } else { -uint8_t x_47; +uint8_t x_48; lean_dec(x_16); lean_dec(x_7); lean_dec(x_4); lean_dec(x_3); lean_dec(x_1); -x_47 = !lean_is_exclusive(x_21); -if (x_47 == 0) +x_48 = !lean_is_exclusive(x_21); +if (x_48 == 0) { return x_21; } else { -lean_object* x_48; lean_object* x_49; lean_object* x_50; -x_48 = lean_ctor_get(x_21, 0); -x_49 = lean_ctor_get(x_21, 1); +lean_object* x_49; lean_object* x_50; lean_object* x_51; +x_49 = lean_ctor_get(x_21, 0); +x_50 = lean_ctor_get(x_21, 1); +lean_inc(x_50); lean_inc(x_49); -lean_inc(x_48); lean_dec(x_21); -x_50 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_50, 0, x_48); -lean_ctor_set(x_50, 1, x_49); -return x_50; +x_51 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_51, 0, x_49); +lean_ctor_set(x_51, 1, x_50); +return x_51; } } }