From cf350e556d3cdc3f0db4ad770b1ac83377ea2169 Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Fri, 30 Apr 2021 18:40:14 -0700 Subject: [PATCH] chore: update stage0 --- stage0/src/Lean/Elab/Match.lean | 4 + stage0/stdlib/Lean/Elab/Match.c | 7757 +++++++++++++----------- stage0/stdlib/Lean/Elab/Tactic/Match.c | 4 +- 3 files changed, 4179 insertions(+), 3586 deletions(-) diff --git a/stage0/src/Lean/Elab/Match.lean b/stage0/src/Lean/Elab/Match.lean index 23ebca691f..ea6aa6cff1 100644 --- a/stage0/src/Lean/Elab/Match.lean +++ b/stage0/src/Lean/Elab/Match.lean @@ -387,6 +387,10 @@ partial def collect (stx : Syntax) : M Syntax := withRef stx <| withFreshMacroSc let pat := stx[2] let pat ← collect pat `(_root_.namedPattern $id $pat) + else if k == ``Lean.Parser.Term.binop then + let lhs ← collect stx[2] + let rhs ← collect stx[3] + return stx.setArg 2 lhs |>.setArg 3 rhs else if k == ``Lean.Parser.Term.inaccessible then return stx else if k == strLitKind then diff --git a/stage0/stdlib/Lean/Elab/Match.c b/stage0/stdlib/Lean/Elab/Match.c index 7f5fda8d85..7a14063738 100644 --- a/stage0/stdlib/Lean/Elab/Match.c +++ b/stage0/stdlib/Lean/Elab/Match.c @@ -147,6 +147,7 @@ extern lean_object* l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; lean_object* l_Lean_mkMVar(lean_object*); size_t l_USize_sub(size_t, size_t); extern lean_object* l_Array_empty___closed__1; +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1; lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_ToDepElimPattern_throwInvalidPattern___rarg___closed__2; extern lean_object* l_myMacro____x40_Init_Notation___hyg_15589____closed__11; lean_object* lean_environment_find(lean_object*, lean_object*); @@ -182,7 +183,6 @@ lean_object* l_Lean_Elab_Term_precheckMatch_match__2___rarg(lean_object*, lean_o lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabDiscrsWitMatchType___closed__1; lean_object* l_Lean_Elab_Term_reportMatcherResultErrors___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_mapM___at_Lean_Elab_Term_ToDepElimPattern_main___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1; lean_object* l_Lean_Elab_Term_ToDepElimPattern_main___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* l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabPatterns___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscrs_loop_match__1___rarg(lean_object*, lean_object*, lean_object*); @@ -221,6 +221,7 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_isMatchUnit_x3f___box lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_getNextParam(lean_object*); lean_object* l_Lean_getConstInfo___at_Lean_Elab_Term_CollectPatternVars_collect_processCtorAppCore___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___spec__1___rarg___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__4; lean_object* l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(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_getAppArgs___closed__1; lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_collectDeps___spec__4(lean_object*, lean_object*, lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -236,6 +237,7 @@ lean_object* l_Lean_Elab_Term_elabMatch_elabMatchDefault_match__1___rarg(lean_ob uint8_t l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_isDone(lean_object*); lean_object* l_Lean_Elab_Term_throwMVarError___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_CollectPatternVars_collect_processCtorAppCore_match__1___rarg(lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__2; lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern(lean_object*); lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_elabMatch_elabMatchDefault___closed__2; @@ -389,6 +391,7 @@ lean_object* lean_nat_sub(lean_object*, lean_object*); lean_object* l_Lean_Meta_Match_Pattern_toExpr_visit(uint8_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_precheckMatch___spec__5___closed__1; lean_object* l_Array_anyMUnsafe_any___at___private_Lean_Elab_Match_0__Lean_Elab_Term_getIndicesToInclude___spec__1(lean_object*, lean_object*, size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__5; lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_nameToPattern___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_isAuxDiscrName___boxed(lean_object*); lean_object* lean_array_swap(lean_object*, lean_object*, lean_object*); @@ -426,6 +429,7 @@ lean_object* l_Lean_Elab_log___at___private_Lean_Elab_Term_0__Lean_Elab_Term_exc lean_object* l_Lean_Elab_Term_CollectPatternVars_collect_processCtorAppCore_match__3(lean_object*); lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_throwEx___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Meta_mkArrow___closed__2; +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__3; lean_object* l_Array_forInUnsafe_loop___at_Lean_Elab_Term_precheckMatch___spec__5___lambda__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_myMacro____x40_Init_NotationExtra___hyg_5717____closed__28; lean_object* l_Lean_replaceRef(lean_object*, lean_object*); @@ -450,7 +454,6 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchTypeAndDiscr lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_nameToPattern___closed__12; lean_object* l_Lean_throwError___at_Lean_Elab_Term_CollectPatternVars_collect_processCtorAppCore___spec__5(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Meta_instantiateLocalDeclMVars(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__2; lean_object* l_Lean_Elab_Term_mkMatcher(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_Quotation_precheckAttribute; lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_isMatchUnit_x3f_match__2(lean_object*); @@ -674,7 +677,6 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_is lean_object* l_Lean_Elab_Term_instToStringPatternVar_match__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_throwAbortTerm___at_Lean_Elab_Term_isAtomicDiscr_x3f___spec__1___rarg(lean_object*); extern lean_object* l_Lean_Syntax_mkApp___closed__1; -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__3; lean_object* l_Array_filterMapM___at___private_Lean_Elab_Match_0__Lean_Elab_Term_getMatchAlts___spec__1___boxed(lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_term_x5b___x5d___closed__5; lean_object* l_List_forIn_loop___at_Lean_Elab_Term_reportMatcherResultErrors___spec__1(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -736,7 +738,6 @@ lean_object* l_Lean_Elab_Term_elabInaccessible___boxed(lean_object*, lean_object lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAux_match__4(lean_object*); lean_object* l_Array_mapMUnsafe_map___at_Lean_Elab_Term_CollectPatternVars_main___spec__3(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_SavedState_restore(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__4; lean_object* l_Array_mapMUnsafe_map___at___private_Lean_Elab_Match_0__Lean_Elab_Term_generalize___spec__2(size_t, size_t, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_Syntax_getArgs(lean_object*); lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -756,7 +757,6 @@ lean_object* l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1___boxed__co lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_collectDeps(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); extern lean_object* l_Lean_Elab_Term_resolveName_x27___closed__2; lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_getNextParam___closed__1; -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__5; lean_object* lean_panic_fn(lean_object*, lean_object*); lean_object* l_Std_Range_forIn_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabPatterns___spec__2___closed__1; lean_object* l_List_forIn_loop___at_Lean_Elab_Term_reportMatcherResultErrors___spec__1___closed__4; @@ -868,6 +868,7 @@ lean_object* l_Lean_Elab_Term_precheckMatch_match__2(lean_object*); lean_object* l_Lean_Elab_Term_ToDepElimPattern_main_match__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* l_Array_qsort_sort___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_collectDeps___spec__6(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Array_forInUnsafe_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabDiscrsWitMatchType___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*); +extern lean_object* l_Lean_Parser_Term_binop___elambda__1___closed__2; lean_object* l_Lean_Elab_Term_withoutErrToSorry___rarg(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_tryPostponeIfDiscrTypeIsMVar(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltView_match__1(lean_object*); @@ -988,8 +989,8 @@ lean_object* l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAux_match__3 lean_object* l_Lean_Elab_Term_isLocalIdent_x3f(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_List_forIn_loop___at___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAux___spec__4___lambda__1___closed__1; lean_object* l_Array_mapMUnsafe_map___at_Lean_Meta_Closure_mkBinding___spec__1(size_t, size_t, lean_object*); -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295_(lean_object*); -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_12006_(lean_object*); +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331_(lean_object*); +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_12042_(lean_object*); lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_2280_(lean_object*); lean_object* l_Lean_mkConst(lean_object*, lean_object*); lean_object* l_Lean_Elab_Term_reportMatcherResultErrors___boxed(lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*, lean_object*); @@ -9155,7 +9156,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_Elab_Term_CollectPatternVars_collect_pushNewArg___closed__4; x_2 = l_Lean_Elab_Term_CollectPatternVars_collect_pushNewArg___closed__5; -x_3 = lean_unsigned_to_nat(443u); +x_3 = lean_unsigned_to_nat(447u); x_4 = lean_unsigned_to_nat(11u); x_5 = l_Lean_Name_getString_x21___closed__3; x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); @@ -9718,33 +9719,33 @@ lean_ctor_set(x_7, 3, x_15); x_16 = lean_st_ref_take(x_8, x_9); if (x_12 == 0) { -lean_object* x_755; lean_object* x_756; uint8_t x_757; -x_755 = lean_ctor_get(x_16, 0); -lean_inc(x_755); -x_756 = lean_ctor_get(x_16, 1); -lean_inc(x_756); +lean_object* x_854; lean_object* x_855; uint8_t x_856; +x_854 = lean_ctor_get(x_16, 0); +lean_inc(x_854); +x_855 = lean_ctor_get(x_16, 1); +lean_inc(x_855); lean_dec(x_16); -x_757 = 0; -x_17 = x_757; -x_18 = x_755; -x_19 = x_756; -goto block_754; +x_856 = 0; +x_17 = x_856; +x_18 = x_854; +x_19 = x_855; +goto block_853; } else { -lean_object* x_758; lean_object* x_759; uint8_t x_760; -x_758 = lean_ctor_get(x_16, 0); -lean_inc(x_758); -x_759 = lean_ctor_get(x_16, 1); -lean_inc(x_759); +lean_object* x_857; lean_object* x_858; uint8_t x_859; +x_857 = lean_ctor_get(x_16, 0); +lean_inc(x_857); +x_858 = lean_ctor_get(x_16, 1); +lean_inc(x_858); lean_dec(x_16); -x_760 = 1; -x_17 = x_760; -x_18 = x_758; -x_19 = x_759; -goto block_754; +x_859 = 1; +x_17 = x_859; +x_18 = x_857; +x_19 = x_858; +goto block_853; } -block_754: +block_853: { uint8_t x_20; x_20 = !lean_is_exclusive(x_18); @@ -9808,64 +9809,55 @@ x_43 = lean_name_eq(x_10, x_42); if (x_43 == 0) { lean_object* x_44; uint8_t x_45; -x_44 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_44 = l_Lean_Parser_Term_binop___elambda__1___closed__2; x_45 = lean_name_eq(x_10, x_44); if (x_45 == 0) { lean_object* x_46; uint8_t x_47; -x_46 = l_Lean_strLitKind; +x_46 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; x_47 = lean_name_eq(x_10, x_46); if (x_47 == 0) { lean_object* x_48; uint8_t x_49; -x_48 = l_Lean_numLitKind; +x_48 = l_Lean_strLitKind; x_49 = lean_name_eq(x_10, x_48); if (x_49 == 0) { lean_object* x_50; uint8_t x_51; -x_50 = l_Lean_scientificLitKind; +x_50 = l_Lean_numLitKind; x_51 = lean_name_eq(x_10, x_50); if (x_51 == 0) { lean_object* x_52; uint8_t x_53; -x_52 = l_Lean_charLitKind; +x_52 = l_Lean_scientificLitKind; x_53 = lean_name_eq(x_10, x_52); if (x_53 == 0) { lean_object* x_54; uint8_t x_55; -lean_free_object(x_24); -x_54 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_54 = l_Lean_charLitKind; x_55 = lean_name_eq(x_10, x_54); if (x_55 == 0) { lean_object* x_56; uint8_t x_57; -x_56 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; +lean_free_object(x_24); +x_56 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; x_57 = lean_name_eq(x_10, x_56); if (x_57 == 0) { lean_object* x_58; uint8_t x_59; -lean_dec(x_1); -x_58 = l_Lean_choiceKind; +x_58 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; x_59 = lean_name_eq(x_10, x_58); -lean_dec(x_10); if (x_59 == 0) { -lean_object* x_60; -x_60 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -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); -return x_60; -} -else +lean_object* x_60; uint8_t x_61; +lean_dec(x_1); +x_60 = l_Lean_choiceKind; +x_61 = lean_name_eq(x_10, x_60); +lean_dec(x_10); +if (x_61 == 0) { -lean_object* x_61; lean_object* x_62; -x_61 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; -x_62 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_61, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +lean_object* x_62; +x_62 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); @@ -9875,38 +9867,52 @@ lean_dec(x_3); lean_dec(x_2); return x_62; } -} else { -lean_object* x_63; -lean_dec(x_10); -lean_dec(x_2); -x_63 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -return x_63; -} -} -else -{ -lean_object* x_64; -lean_dec(x_10); -lean_dec(x_2); -x_64 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +lean_object* x_63; lean_object* x_64; +x_63 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; +x_64 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_63, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); lean_dec(x_8); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_1); +lean_dec(x_3); +lean_dec(x_2); return x_64; } } else { +lean_object* x_65; +lean_dec(x_10); +lean_dec(x_2); +x_65 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_65; +} +} +else +{ +lean_object* x_66; +lean_dec(x_10); +lean_dec(x_2); +x_66 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_66; +} +} +else +{ lean_dec(x_3); lean_dec(x_7); lean_dec(x_10); @@ -9977,22 +9983,134 @@ return x_24; } else { -lean_object* x_65; lean_object* x_66; lean_object* x_67; +lean_object* x_67; lean_object* x_68; lean_object* x_69; lean_free_object(x_24); lean_dec(x_10); -x_65 = lean_unsigned_to_nat(0u); -x_66 = l_Lean_Syntax_getArg(x_1, x_65); +x_67 = lean_unsigned_to_nat(2u); +x_68 = l_Lean_Syntax_getArg(x_1, x_67); +lean_inc(x_8); lean_inc(x_7); -lean_inc(x_66); -x_67 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_66, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -if (lean_obj_tag(x_67) == 0) +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_3); +lean_inc(x_2); +x_69 = l_Lean_Elab_Term_CollectPatternVars_collect(x_68, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_69) == 0) { -lean_object* x_68; lean_object* x_69; lean_object* x_70; lean_object* x_71; -x_68 = lean_ctor_get(x_67, 1); -lean_inc(x_68); -lean_dec(x_67); -x_69 = lean_unsigned_to_nat(2u); -x_70 = l_Lean_Syntax_getArg(x_1, x_69); +lean_object* x_70; lean_object* x_71; lean_object* x_72; lean_object* x_73; lean_object* x_74; +x_70 = lean_ctor_get(x_69, 0); +lean_inc(x_70); +x_71 = lean_ctor_get(x_69, 1); +lean_inc(x_71); +lean_dec(x_69); +x_72 = lean_unsigned_to_nat(3u); +x_73 = l_Lean_Syntax_getArg(x_1, x_72); +x_74 = l_Lean_Elab_Term_CollectPatternVars_collect(x_73, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_71); +if (lean_obj_tag(x_74) == 0) +{ +uint8_t x_75; +x_75 = !lean_is_exclusive(x_74); +if (x_75 == 0) +{ +lean_object* x_76; lean_object* x_77; lean_object* x_78; +x_76 = lean_ctor_get(x_74, 0); +x_77 = l_Lean_Syntax_setArg(x_1, x_67, x_70); +x_78 = l_Lean_Syntax_setArg(x_77, x_72, x_76); +lean_ctor_set(x_74, 0, x_78); +return x_74; +} +else +{ +lean_object* x_79; lean_object* x_80; lean_object* x_81; lean_object* x_82; lean_object* x_83; +x_79 = lean_ctor_get(x_74, 0); +x_80 = lean_ctor_get(x_74, 1); +lean_inc(x_80); +lean_inc(x_79); +lean_dec(x_74); +x_81 = l_Lean_Syntax_setArg(x_1, x_67, x_70); +x_82 = l_Lean_Syntax_setArg(x_81, x_72, x_79); +x_83 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_83, 0, x_82); +lean_ctor_set(x_83, 1, x_80); +return x_83; +} +} +else +{ +uint8_t x_84; +lean_dec(x_70); +lean_dec(x_1); +x_84 = !lean_is_exclusive(x_74); +if (x_84 == 0) +{ +return x_74; +} +else +{ +lean_object* x_85; lean_object* x_86; lean_object* x_87; +x_85 = lean_ctor_get(x_74, 0); +x_86 = lean_ctor_get(x_74, 1); +lean_inc(x_86); +lean_inc(x_85); +lean_dec(x_74); +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_88; +lean_dec(x_3); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_88 = !lean_is_exclusive(x_69); +if (x_88 == 0) +{ +return x_69; +} +else +{ +lean_object* x_89; lean_object* x_90; lean_object* x_91; +x_89 = lean_ctor_get(x_69, 0); +x_90 = lean_ctor_get(x_69, 1); +lean_inc(x_90); +lean_inc(x_89); +lean_dec(x_69); +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; +lean_free_object(x_24); +lean_dec(x_10); +x_92 = lean_unsigned_to_nat(0u); +x_93 = l_Lean_Syntax_getArg(x_1, x_92); +lean_inc(x_7); +lean_inc(x_93); +x_94 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_93, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_94) == 0) +{ +lean_object* x_95; lean_object* x_96; lean_object* x_97; lean_object* x_98; +x_95 = lean_ctor_get(x_94, 1); +lean_inc(x_95); +lean_dec(x_94); +x_96 = lean_unsigned_to_nat(2u); +x_97 = l_Lean_Syntax_getArg(x_1, x_96); lean_dec(x_1); lean_inc(x_8); lean_inc(x_7); @@ -10000,261 +10118,153 @@ lean_inc(x_6); lean_inc(x_5); lean_inc(x_4); lean_inc(x_3); -x_71 = l_Lean_Elab_Term_CollectPatternVars_collect(x_70, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_68); -if (lean_obj_tag(x_71) == 0) +x_98 = l_Lean_Elab_Term_CollectPatternVars_collect(x_97, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_95); +if (lean_obj_tag(x_98) == 0) { -lean_object* x_72; lean_object* x_73; lean_object* x_74; lean_object* x_75; lean_object* x_76; lean_object* x_77; lean_object* x_78; lean_object* x_79; lean_object* x_80; uint8_t x_81; -x_72 = lean_ctor_get(x_71, 0); -lean_inc(x_72); -x_73 = lean_ctor_get(x_71, 1); -lean_inc(x_73); -lean_dec(x_71); -x_74 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, 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 = l_Lean_Elab_Term_getCurrMacroScope(x_3, x_4, x_5, x_6, x_7, x_8, x_76); +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; uint8_t x_108; +x_99 = lean_ctor_get(x_98, 0); +lean_inc(x_99); +x_100 = lean_ctor_get(x_98, 1); +lean_inc(x_100); +lean_dec(x_98); +x_101 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_100); +x_102 = lean_ctor_get(x_101, 0); +lean_inc(x_102); +x_103 = lean_ctor_get(x_101, 1); +lean_inc(x_103); +lean_dec(x_101); +x_104 = l_Lean_Elab_Term_getCurrMacroScope(x_3, x_4, x_5, x_6, x_7, x_8, x_103); lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_3); -x_78 = lean_ctor_get(x_77, 0); -lean_inc(x_78); -x_79 = lean_ctor_get(x_77, 1); -lean_inc(x_79); -lean_dec(x_77); -x_80 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_79); +x_105 = lean_ctor_get(x_104, 0); +lean_inc(x_105); +x_106 = lean_ctor_get(x_104, 1); +lean_inc(x_106); +lean_dec(x_104); +x_107 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_106); lean_dec(x_8); -x_81 = !lean_is_exclusive(x_80); -if (x_81 == 0) +x_108 = !lean_is_exclusive(x_107); +if (x_108 == 0) { -lean_object* x_82; lean_object* x_83; lean_object* x_84; lean_object* x_85; lean_object* x_86; lean_object* x_87; lean_object* x_88; lean_object* x_89; lean_object* x_90; lean_object* x_91; lean_object* x_92; lean_object* x_93; lean_object* x_94; lean_object* x_95; -x_82 = lean_ctor_get(x_80, 0); -x_83 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; -x_84 = l_Lean_addMacroScope(x_82, x_83, x_78); -x_85 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; -x_86 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; -x_87 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_87, 0, x_75); -lean_ctor_set(x_87, 1, x_85); -lean_ctor_set(x_87, 2, x_84); -lean_ctor_set(x_87, 3, x_86); -x_88 = l_Array_empty___closed__1; -x_89 = lean_array_push(x_88, x_87); -x_90 = lean_array_push(x_88, x_66); -x_91 = lean_array_push(x_90, x_72); -x_92 = l_Lean_nullKind___closed__2; -x_93 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_93, 0, x_92); -lean_ctor_set(x_93, 1, x_91); -x_94 = lean_array_push(x_89, x_93); -x_95 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_95, 0, x_30); -lean_ctor_set(x_95, 1, x_94); -lean_ctor_set(x_80, 0, x_95); -return x_80; +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_109 = lean_ctor_get(x_107, 0); +x_110 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; +x_111 = l_Lean_addMacroScope(x_109, x_110, x_105); +x_112 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; +x_113 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; +x_114 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_114, 0, x_102); +lean_ctor_set(x_114, 1, x_112); +lean_ctor_set(x_114, 2, x_111); +lean_ctor_set(x_114, 3, x_113); +x_115 = l_Array_empty___closed__1; +x_116 = lean_array_push(x_115, x_114); +x_117 = lean_array_push(x_115, x_93); +x_118 = lean_array_push(x_117, x_99); +x_119 = l_Lean_nullKind___closed__2; +x_120 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_120, 0, x_119); +lean_ctor_set(x_120, 1, x_118); +x_121 = lean_array_push(x_116, x_120); +x_122 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_122, 0, x_30); +lean_ctor_set(x_122, 1, x_121); +lean_ctor_set(x_107, 0, x_122); +return x_107; } else { -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; -x_96 = lean_ctor_get(x_80, 0); -x_97 = lean_ctor_get(x_80, 1); -lean_inc(x_97); -lean_inc(x_96); -lean_dec(x_80); -x_98 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; -x_99 = l_Lean_addMacroScope(x_96, x_98, x_78); -x_100 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; -x_101 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; -x_102 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_102, 0, x_75); -lean_ctor_set(x_102, 1, x_100); -lean_ctor_set(x_102, 2, x_99); -lean_ctor_set(x_102, 3, x_101); -x_103 = l_Array_empty___closed__1; -x_104 = lean_array_push(x_103, x_102); -x_105 = lean_array_push(x_103, x_66); -x_106 = lean_array_push(x_105, x_72); -x_107 = l_Lean_nullKind___closed__2; -x_108 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_108, 0, x_107); -lean_ctor_set(x_108, 1, x_106); -x_109 = lean_array_push(x_104, x_108); -x_110 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_110, 0, x_30); -lean_ctor_set(x_110, 1, x_109); -x_111 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_111, 0, x_110); -lean_ctor_set(x_111, 1, x_97); -return x_111; +lean_object* x_123; lean_object* x_124; lean_object* x_125; lean_object* x_126; lean_object* x_127; lean_object* x_128; lean_object* x_129; lean_object* x_130; lean_object* x_131; lean_object* x_132; lean_object* x_133; lean_object* x_134; lean_object* x_135; lean_object* x_136; lean_object* x_137; lean_object* x_138; +x_123 = lean_ctor_get(x_107, 0); +x_124 = lean_ctor_get(x_107, 1); +lean_inc(x_124); +lean_inc(x_123); +lean_dec(x_107); +x_125 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; +x_126 = l_Lean_addMacroScope(x_123, x_125, x_105); +x_127 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; +x_128 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; +x_129 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_129, 0, x_102); +lean_ctor_set(x_129, 1, x_127); +lean_ctor_set(x_129, 2, x_126); +lean_ctor_set(x_129, 3, x_128); +x_130 = l_Array_empty___closed__1; +x_131 = lean_array_push(x_130, x_129); +x_132 = lean_array_push(x_130, x_93); +x_133 = lean_array_push(x_132, x_99); +x_134 = l_Lean_nullKind___closed__2; +x_135 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_135, 0, x_134); +lean_ctor_set(x_135, 1, x_133); +x_136 = lean_array_push(x_131, x_135); +x_137 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_137, 0, x_30); +lean_ctor_set(x_137, 1, x_136); +x_138 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_138, 0, x_137); +lean_ctor_set(x_138, 1, x_124); +return x_138; } } else { -uint8_t x_112; -lean_dec(x_66); +uint8_t x_139; +lean_dec(x_93); lean_dec(x_3); lean_dec(x_7); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -x_112 = !lean_is_exclusive(x_71); -if (x_112 == 0) +x_139 = !lean_is_exclusive(x_98); +if (x_139 == 0) { -return x_71; +return x_98; } else { -lean_object* x_113; lean_object* x_114; lean_object* x_115; -x_113 = lean_ctor_get(x_71, 0); -x_114 = lean_ctor_get(x_71, 1); -lean_inc(x_114); -lean_inc(x_113); -lean_dec(x_71); -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; -} -} -} -else -{ -uint8_t x_116; -lean_dec(x_66); -lean_dec(x_3); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_116 = !lean_is_exclusive(x_67); -if (x_116 == 0) -{ -return x_67; -} -else -{ -lean_object* x_117; lean_object* x_118; lean_object* x_119; -x_117 = lean_ctor_get(x_67, 0); -x_118 = lean_ctor_get(x_67, 1); -lean_inc(x_118); -lean_inc(x_117); -lean_dec(x_67); -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; -} -} -} -} -else -{ -lean_object* x_120; lean_object* x_121; lean_object* x_122; -lean_free_object(x_24); -lean_dec(x_10); -x_120 = lean_unsigned_to_nat(0u); -x_121 = l_Lean_Syntax_getArg(x_1, x_120); -lean_dec(x_1); -x_122 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_121, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -return x_122; -} -} -else -{ -lean_object* x_123; uint8_t x_124; -lean_dec(x_10); -x_123 = l_Lean_Syntax_getArg(x_1, x_22); -x_124 = l_Lean_Syntax_isNone(x_123); -if (x_124 == 0) -{ -lean_object* x_125; lean_object* x_126; lean_object* x_127; uint8_t x_128; -x_125 = lean_unsigned_to_nat(0u); -x_126 = l_Lean_Syntax_getArg(x_123, x_125); -x_127 = l_Lean_Syntax_getArg(x_123, x_22); -x_128 = l_Lean_Syntax_isNone(x_127); -if (x_128 == 0) -{ -lean_object* x_129; lean_object* x_130; lean_object* x_131; uint8_t x_132; -x_129 = l_Lean_Syntax_getArg(x_127, x_125); -lean_dec(x_127); -x_130 = l_Lean_Syntax_getKind(x_129); -x_131 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; -x_132 = lean_name_eq(x_130, x_131); -lean_dec(x_130); -if (x_132 == 0) -{ -lean_dec(x_126); -lean_dec(x_123); -lean_dec(x_3); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -else -{ -lean_object* x_133; -lean_free_object(x_24); -x_133 = l_Lean_Elab_Term_CollectPatternVars_collect(x_126, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -if (lean_obj_tag(x_133) == 0) -{ -uint8_t x_134; -x_134 = !lean_is_exclusive(x_133); -if (x_134 == 0) -{ -lean_object* x_135; lean_object* x_136; lean_object* x_137; -x_135 = lean_ctor_get(x_133, 0); -x_136 = l_Lean_Syntax_setArg(x_123, x_125, x_135); -x_137 = l_Lean_Syntax_setArg(x_1, x_22, x_136); -lean_ctor_set(x_133, 0, x_137); -return x_133; -} -else -{ -lean_object* x_138; lean_object* x_139; lean_object* x_140; lean_object* x_141; lean_object* x_142; -x_138 = lean_ctor_get(x_133, 0); -x_139 = lean_ctor_get(x_133, 1); -lean_inc(x_139); -lean_inc(x_138); -lean_dec(x_133); -x_140 = l_Lean_Syntax_setArg(x_123, x_125, x_138); -x_141 = l_Lean_Syntax_setArg(x_1, x_22, x_140); -x_142 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_142, 0, x_141); -lean_ctor_set(x_142, 1, x_139); +lean_object* x_140; lean_object* x_141; lean_object* x_142; +x_140 = lean_ctor_get(x_98, 0); +x_141 = lean_ctor_get(x_98, 1); +lean_inc(x_141); +lean_inc(x_140); +lean_dec(x_98); +x_142 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_142, 0, x_140); +lean_ctor_set(x_142, 1, x_141); return x_142; } } +} else { uint8_t x_143; -lean_dec(x_123); +lean_dec(x_93); +lean_dec(x_3); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); lean_dec(x_1); -x_143 = !lean_is_exclusive(x_133); +x_143 = !lean_is_exclusive(x_94); if (x_143 == 0) { -return x_133; +return x_94; } else { lean_object* x_144; lean_object* x_145; lean_object* x_146; -x_144 = lean_ctor_get(x_133, 0); -x_145 = lean_ctor_get(x_133, 1); +x_144 = lean_ctor_get(x_94, 0); +x_145 = lean_ctor_get(x_94, 1); lean_inc(x_145); lean_inc(x_144); -lean_dec(x_133); +lean_dec(x_94); x_146 = lean_alloc_ctor(1, 2, 0); lean_ctor_set(x_146, 0, x_144); lean_ctor_set(x_146, 1, x_145); @@ -10265,68 +10275,42 @@ return x_146; } else { -lean_object* x_147; -lean_dec(x_127); +lean_object* x_147; lean_object* x_148; lean_object* x_149; lean_free_object(x_24); -x_147 = l_Lean_Elab_Term_CollectPatternVars_collect(x_126, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -if (lean_obj_tag(x_147) == 0) -{ -uint8_t x_148; -x_148 = !lean_is_exclusive(x_147); -if (x_148 == 0) -{ -lean_object* x_149; lean_object* x_150; lean_object* x_151; -x_149 = lean_ctor_get(x_147, 0); -x_150 = l_Lean_Syntax_setArg(x_123, x_125, x_149); -x_151 = l_Lean_Syntax_setArg(x_1, x_22, x_150); -lean_ctor_set(x_147, 0, x_151); -return x_147; -} -else -{ -lean_object* x_152; lean_object* x_153; lean_object* x_154; lean_object* x_155; lean_object* x_156; -x_152 = lean_ctor_get(x_147, 0); -x_153 = lean_ctor_get(x_147, 1); -lean_inc(x_153); -lean_inc(x_152); -lean_dec(x_147); -x_154 = l_Lean_Syntax_setArg(x_123, x_125, x_152); -x_155 = l_Lean_Syntax_setArg(x_1, x_22, x_154); -x_156 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_156, 0, x_155); -lean_ctor_set(x_156, 1, x_153); -return x_156; -} -} -else -{ -uint8_t x_157; -lean_dec(x_123); +lean_dec(x_10); +x_147 = lean_unsigned_to_nat(0u); +x_148 = l_Lean_Syntax_getArg(x_1, x_147); lean_dec(x_1); -x_157 = !lean_is_exclusive(x_147); -if (x_157 == 0) -{ -return x_147; -} -else -{ -lean_object* x_158; lean_object* x_159; lean_object* x_160; -x_158 = lean_ctor_get(x_147, 0); -x_159 = lean_ctor_get(x_147, 1); -lean_inc(x_159); -lean_inc(x_158); -lean_dec(x_147); -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; -} -} +x_149 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_148, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +return x_149; } } else { -lean_dec(x_123); +lean_object* x_150; uint8_t x_151; +lean_dec(x_10); +x_150 = l_Lean_Syntax_getArg(x_1, x_22); +x_151 = l_Lean_Syntax_isNone(x_150); +if (x_151 == 0) +{ +lean_object* x_152; lean_object* x_153; lean_object* x_154; uint8_t x_155; +x_152 = lean_unsigned_to_nat(0u); +x_153 = l_Lean_Syntax_getArg(x_150, x_152); +x_154 = l_Lean_Syntax_getArg(x_150, x_22); +x_155 = l_Lean_Syntax_isNone(x_154); +if (x_155 == 0) +{ +lean_object* x_156; lean_object* x_157; lean_object* x_158; uint8_t x_159; +x_156 = l_Lean_Syntax_getArg(x_154, x_152); +lean_dec(x_154); +x_157 = l_Lean_Syntax_getKind(x_156); +x_158 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; +x_159 = lean_name_eq(x_157, x_158); +lean_dec(x_157); +if (x_159 == 0) +{ +lean_dec(x_153); +lean_dec(x_150); lean_dec(x_3); lean_dec(x_7); lean_dec(x_8); @@ -10337,2877 +10321,2284 @@ lean_dec(x_2); lean_ctor_set(x_24, 0, x_1); return x_24; } +else +{ +lean_object* x_160; +lean_free_object(x_24); +x_160 = l_Lean_Elab_Term_CollectPatternVars_collect(x_153, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_160) == 0) +{ +uint8_t x_161; +x_161 = !lean_is_exclusive(x_160); +if (x_161 == 0) +{ +lean_object* x_162; lean_object* x_163; lean_object* x_164; +x_162 = lean_ctor_get(x_160, 0); +x_163 = l_Lean_Syntax_setArg(x_150, x_152, x_162); +x_164 = l_Lean_Syntax_setArg(x_1, x_22, x_163); +lean_ctor_set(x_160, 0, x_164); +return x_160; +} +else +{ +lean_object* x_165; lean_object* x_166; lean_object* x_167; lean_object* x_168; lean_object* x_169; +x_165 = lean_ctor_get(x_160, 0); +x_166 = lean_ctor_get(x_160, 1); +lean_inc(x_166); +lean_inc(x_165); +lean_dec(x_160); +x_167 = l_Lean_Syntax_setArg(x_150, x_152, x_165); +x_168 = l_Lean_Syntax_setArg(x_1, x_22, x_167); +x_169 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_169, 0, x_168); +lean_ctor_set(x_169, 1, x_166); +return x_169; } } 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; uint8_t x_169; -lean_dec(x_3); -lean_free_object(x_24); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); +uint8_t x_170; +lean_dec(x_150); lean_dec(x_1); -x_161 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_26); -x_162 = lean_ctor_get(x_161, 0); -lean_inc(x_162); -x_163 = lean_ctor_get(x_161, 1); -lean_inc(x_163); -lean_dec(x_161); -x_164 = lean_st_ref_get(x_8, x_163); -lean_dec(x_8); -x_165 = lean_ctor_get(x_164, 1); -lean_inc(x_165); -lean_dec(x_164); -x_166 = lean_st_ref_take(x_2, x_165); -x_167 = lean_ctor_get(x_166, 0); -lean_inc(x_167); -x_168 = lean_ctor_get(x_166, 1); -lean_inc(x_168); -lean_dec(x_166); -x_169 = !lean_is_exclusive(x_167); -if (x_169 == 0) +x_170 = !lean_is_exclusive(x_160); +if (x_170 == 0) { -lean_object* x_170; lean_object* x_171; lean_object* x_172; lean_object* x_173; lean_object* x_174; uint8_t x_175; -x_170 = lean_ctor_get(x_167, 1); -x_171 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_162); -x_172 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_172, 0, x_171); -x_173 = lean_array_push(x_170, x_172); -lean_ctor_set(x_167, 1, x_173); -x_174 = lean_st_ref_set(x_2, x_167, x_168); -lean_dec(x_2); +return x_160; +} +else +{ +lean_object* x_171; lean_object* x_172; lean_object* x_173; +x_171 = lean_ctor_get(x_160, 0); +x_172 = lean_ctor_get(x_160, 1); +lean_inc(x_172); +lean_inc(x_171); +lean_dec(x_160); +x_173 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_173, 0, x_171); +lean_ctor_set(x_173, 1, x_172); +return x_173; +} +} +} +} +else +{ +lean_object* x_174; +lean_dec(x_154); +lean_free_object(x_24); +x_174 = l_Lean_Elab_Term_CollectPatternVars_collect(x_153, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_174) == 0) +{ +uint8_t x_175; x_175 = !lean_is_exclusive(x_174); if (x_175 == 0) { -lean_object* x_176; +lean_object* x_176; lean_object* x_177; lean_object* x_178; x_176 = lean_ctor_get(x_174, 0); -lean_dec(x_176); -lean_ctor_set(x_174, 0, x_162); +x_177 = l_Lean_Syntax_setArg(x_150, x_152, x_176); +x_178 = l_Lean_Syntax_setArg(x_1, x_22, x_177); +lean_ctor_set(x_174, 0, x_178); return x_174; } else { -lean_object* x_177; lean_object* x_178; -x_177 = lean_ctor_get(x_174, 1); -lean_inc(x_177); -lean_dec(x_174); -x_178 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_178, 0, x_162); -lean_ctor_set(x_178, 1, x_177); -return x_178; -} -} -else -{ -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; -x_179 = lean_ctor_get(x_167, 0); -x_180 = lean_ctor_get(x_167, 1); +lean_object* x_179; lean_object* x_180; lean_object* x_181; lean_object* x_182; lean_object* x_183; +x_179 = lean_ctor_get(x_174, 0); +x_180 = lean_ctor_get(x_174, 1); lean_inc(x_180); lean_inc(x_179); -lean_dec(x_167); -x_181 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_162); -x_182 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_182, 0, x_181); -x_183 = lean_array_push(x_180, x_182); -x_184 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_184, 0, x_179); -lean_ctor_set(x_184, 1, x_183); -x_185 = lean_st_ref_set(x_2, x_184, x_168); -lean_dec(x_2); -x_186 = lean_ctor_get(x_185, 1); +lean_dec(x_174); +x_181 = l_Lean_Syntax_setArg(x_150, x_152, x_179); +x_182 = l_Lean_Syntax_setArg(x_1, x_22, x_181); +x_183 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_183, 0, x_182); +lean_ctor_set(x_183, 1, x_180); +return x_183; +} +} +else +{ +uint8_t x_184; +lean_dec(x_150); +lean_dec(x_1); +x_184 = !lean_is_exclusive(x_174); +if (x_184 == 0) +{ +return x_174; +} +else +{ +lean_object* x_185; lean_object* x_186; lean_object* x_187; +x_185 = lean_ctor_get(x_174, 0); +x_186 = lean_ctor_get(x_174, 1); lean_inc(x_186); -if (lean_is_exclusive(x_185)) { - lean_ctor_release(x_185, 0); - lean_ctor_release(x_185, 1); - x_187 = x_185; -} else { - lean_dec_ref(x_185); - x_187 = lean_box(0); +lean_inc(x_185); +lean_dec(x_174); +x_187 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_187, 0, x_185); +lean_ctor_set(x_187, 1, x_186); +return x_187; } -if (lean_is_scalar(x_187)) { - x_188 = lean_alloc_ctor(0, 2, 0); -} else { - x_188 = x_187; -} -lean_ctor_set(x_188, 0, x_162); -lean_ctor_set(x_188, 1, x_186); -return x_188; } } } else { -lean_object* x_189; uint8_t x_190; +lean_dec(x_150); +lean_dec(x_3); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +} +else +{ +lean_object* x_188; lean_object* x_189; lean_object* x_190; lean_object* x_191; lean_object* x_192; lean_object* x_193; lean_object* x_194; lean_object* x_195; uint8_t x_196; +lean_dec(x_3); +lean_free_object(x_24); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_188 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_26); +x_189 = lean_ctor_get(x_188, 0); +lean_inc(x_189); +x_190 = lean_ctor_get(x_188, 1); +lean_inc(x_190); +lean_dec(x_188); +x_191 = lean_st_ref_get(x_8, x_190); +lean_dec(x_8); +x_192 = lean_ctor_get(x_191, 1); +lean_inc(x_192); +lean_dec(x_191); +x_193 = lean_st_ref_take(x_2, x_192); +x_194 = lean_ctor_get(x_193, 0); +lean_inc(x_194); +x_195 = lean_ctor_get(x_193, 1); +lean_inc(x_195); +lean_dec(x_193); +x_196 = !lean_is_exclusive(x_194); +if (x_196 == 0) +{ +lean_object* x_197; lean_object* x_198; lean_object* x_199; lean_object* x_200; lean_object* x_201; uint8_t x_202; +x_197 = lean_ctor_get(x_194, 1); +x_198 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_189); +x_199 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_199, 0, x_198); +x_200 = lean_array_push(x_197, x_199); +lean_ctor_set(x_194, 1, x_200); +x_201 = lean_st_ref_set(x_2, x_194, x_195); +lean_dec(x_2); +x_202 = !lean_is_exclusive(x_201); +if (x_202 == 0) +{ +lean_object* x_203; +x_203 = lean_ctor_get(x_201, 0); +lean_dec(x_203); +lean_ctor_set(x_201, 0, x_189); +return x_201; +} +else +{ +lean_object* x_204; lean_object* x_205; +x_204 = lean_ctor_get(x_201, 1); +lean_inc(x_204); +lean_dec(x_201); +x_205 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_205, 0, x_189); +lean_ctor_set(x_205, 1, x_204); +return x_205; +} +} +else +{ +lean_object* x_206; lean_object* x_207; lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; lean_object* x_214; lean_object* x_215; +x_206 = lean_ctor_get(x_194, 0); +x_207 = lean_ctor_get(x_194, 1); +lean_inc(x_207); +lean_inc(x_206); +lean_dec(x_194); +x_208 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_189); +x_209 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_209, 0, x_208); +x_210 = lean_array_push(x_207, x_209); +x_211 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_211, 0, x_206); +lean_ctor_set(x_211, 1, x_210); +x_212 = lean_st_ref_set(x_2, x_211, x_195); +lean_dec(x_2); +x_213 = lean_ctor_get(x_212, 1); +lean_inc(x_213); +if (lean_is_exclusive(x_212)) { + lean_ctor_release(x_212, 0); + lean_ctor_release(x_212, 1); + x_214 = x_212; +} else { + lean_dec_ref(x_212); + x_214 = lean_box(0); +} +if (lean_is_scalar(x_214)) { + x_215 = lean_alloc_ctor(0, 2, 0); +} else { + x_215 = x_214; +} +lean_ctor_set(x_215, 0, x_189); +lean_ctor_set(x_215, 1, x_213); +return x_215; +} +} +} +else +{ +lean_object* x_216; uint8_t x_217; lean_free_object(x_24); lean_dec(x_10); -x_189 = l_Lean_Syntax_getArg(x_1, x_22); -x_190 = l_Lean_Syntax_isNone(x_189); -if (x_190 == 0) +x_216 = l_Lean_Syntax_getArg(x_1, x_22); +x_217 = l_Lean_Syntax_isNone(x_216); +if (x_217 == 0) { -lean_object* x_191; lean_object* x_192; uint8_t x_193; +lean_object* x_218; lean_object* x_219; uint8_t x_220; lean_dec(x_1); -x_191 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; -x_192 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_189, x_191, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +x_218 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; +x_219 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_216, x_218, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); 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_189); -x_193 = !lean_is_exclusive(x_192); -if (x_193 == 0) +lean_dec(x_216); +x_220 = !lean_is_exclusive(x_219); +if (x_220 == 0) { -return x_192; -} -else -{ -lean_object* x_194; lean_object* x_195; lean_object* x_196; -x_194 = lean_ctor_get(x_192, 0); -x_195 = lean_ctor_get(x_192, 1); -lean_inc(x_195); -lean_inc(x_194); -lean_dec(x_192); -x_196 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_196, 0, x_194); -lean_ctor_set(x_196, 1, x_195); -return x_196; -} -} -else -{ -lean_object* x_197; lean_object* x_198; -lean_dec(x_189); -x_197 = lean_box(0); -x_198 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_197, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -return x_198; -} -} -} -else -{ -lean_object* x_199; lean_object* x_200; lean_object* x_201; lean_object* x_202; -lean_free_object(x_24); -lean_dec(x_10); -x_199 = l_Lean_Syntax_getArg(x_1, x_22); -x_200 = l_Lean_Syntax_getArgs(x_199); -lean_dec(x_199); -x_201 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; -x_202 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_200, x_201, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_200); -if (lean_obj_tag(x_202) == 0) -{ -uint8_t x_203; -x_203 = !lean_is_exclusive(x_202); -if (x_203 == 0) -{ -lean_object* x_204; lean_object* x_205; lean_object* x_206; lean_object* x_207; -x_204 = lean_ctor_get(x_202, 0); -x_205 = l_Lean_nullKind; -x_206 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_206, 0, x_205); -lean_ctor_set(x_206, 1, x_204); -x_207 = l_Lean_Syntax_setArg(x_1, x_22, x_206); -lean_ctor_set(x_202, 0, x_207); -return x_202; -} -else -{ -lean_object* x_208; lean_object* x_209; lean_object* x_210; lean_object* x_211; lean_object* x_212; lean_object* x_213; -x_208 = lean_ctor_get(x_202, 0); -x_209 = lean_ctor_get(x_202, 1); -lean_inc(x_209); -lean_inc(x_208); -lean_dec(x_202); -x_210 = l_Lean_nullKind; -x_211 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_211, 0, x_210); -lean_ctor_set(x_211, 1, x_208); -x_212 = l_Lean_Syntax_setArg(x_1, x_22, x_211); -x_213 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_213, 0, x_212); -lean_ctor_set(x_213, 1, x_209); -return x_213; -} -} -else -{ -uint8_t x_214; -lean_dec(x_1); -x_214 = !lean_is_exclusive(x_202); -if (x_214 == 0) -{ -return x_202; -} -else -{ -lean_object* x_215; lean_object* x_216; lean_object* x_217; -x_215 = lean_ctor_get(x_202, 0); -x_216 = lean_ctor_get(x_202, 1); -lean_inc(x_216); -lean_inc(x_215); -lean_dec(x_202); -x_217 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_217, 0, x_215); -lean_ctor_set(x_217, 1, x_216); -return x_217; -} -} -} -} -else -{ -lean_object* x_218; -lean_free_object(x_24); -lean_dec(x_10); -x_218 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_1); -return x_218; -} -} -else -{ -lean_object* x_219; -lean_free_object(x_24); -lean_dec(x_10); -x_219 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); return x_219; } -} else { -lean_object* x_220; lean_object* x_221; lean_object* x_222; lean_object* x_223; uint8_t x_224; uint8_t x_225; uint8_t x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; uint8_t x_230; lean_object* x_231; -x_220 = lean_ctor_get(x_3, 0); -x_221 = lean_ctor_get(x_3, 1); -x_222 = lean_ctor_get(x_3, 2); -x_223 = lean_ctor_get(x_3, 3); -x_224 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); -x_225 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); -x_226 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); -x_227 = lean_ctor_get(x_3, 5); -x_228 = lean_ctor_get(x_3, 6); -x_229 = lean_ctor_get(x_3, 7); -x_230 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); -lean_inc(x_229); -lean_inc(x_228); -lean_inc(x_227); -lean_inc(x_223); +lean_object* x_221; lean_object* x_222; lean_object* x_223; +x_221 = lean_ctor_get(x_219, 0); +x_222 = lean_ctor_get(x_219, 1); lean_inc(x_222); lean_inc(x_221); -lean_inc(x_220); -lean_dec(x_3); -x_231 = lean_alloc_ctor(0, 8, 4); -lean_ctor_set(x_231, 0, x_220); -lean_ctor_set(x_231, 1, x_221); -lean_ctor_set(x_231, 2, x_222); -lean_ctor_set(x_231, 3, x_223); -lean_ctor_set(x_231, 4, x_21); -lean_ctor_set(x_231, 5, x_227); -lean_ctor_set(x_231, 6, x_228); -lean_ctor_set(x_231, 7, x_229); -lean_ctor_set_uint8(x_231, sizeof(void*)*8, x_224); -lean_ctor_set_uint8(x_231, sizeof(void*)*8 + 1, x_225); -lean_ctor_set_uint8(x_231, sizeof(void*)*8 + 2, x_226); -lean_ctor_set_uint8(x_231, sizeof(void*)*8 + 3, x_230); -if (x_17 == 0) +lean_dec(x_219); +x_223 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_223, 0, x_221); +lean_ctor_set(x_223, 1, x_222); +return x_223; +} +} +else { -lean_object* x_232; uint8_t x_233; -x_232 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; -x_233 = lean_name_eq(x_10, x_232); -if (x_233 == 0) +lean_object* x_224; lean_object* x_225; +lean_dec(x_216); +x_224 = lean_box(0); +x_225 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_224, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +return x_225; +} +} +} +else { -lean_object* x_234; uint8_t x_235; -x_234 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_235 = lean_name_eq(x_10, x_234); -if (x_235 == 0) +lean_object* x_226; lean_object* x_227; lean_object* x_228; lean_object* x_229; +lean_free_object(x_24); +lean_dec(x_10); +x_226 = l_Lean_Syntax_getArg(x_1, x_22); +x_227 = l_Lean_Syntax_getArgs(x_226); +lean_dec(x_226); +x_228 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; +x_229 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_227, x_228, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_227); +if (lean_obj_tag(x_229) == 0) { -lean_object* x_236; uint8_t x_237; -x_236 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; -x_237 = lean_name_eq(x_10, x_236); -if (x_237 == 0) +uint8_t x_230; +x_230 = !lean_is_exclusive(x_229); +if (x_230 == 0) { -lean_object* x_238; uint8_t x_239; -x_238 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; -x_239 = lean_name_eq(x_10, x_238); -if (x_239 == 0) +lean_object* x_231; lean_object* x_232; lean_object* x_233; lean_object* x_234; +x_231 = lean_ctor_get(x_229, 0); +x_232 = l_Lean_nullKind; +x_233 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_233, 0, x_232); +lean_ctor_set(x_233, 1, x_231); +x_234 = l_Lean_Syntax_setArg(x_1, x_22, x_233); +lean_ctor_set(x_229, 0, x_234); +return x_229; +} +else { -lean_object* x_240; uint8_t x_241; -x_240 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; -x_241 = lean_name_eq(x_10, x_240); +lean_object* x_235; lean_object* x_236; lean_object* x_237; lean_object* x_238; lean_object* x_239; lean_object* x_240; +x_235 = lean_ctor_get(x_229, 0); +x_236 = lean_ctor_get(x_229, 1); +lean_inc(x_236); +lean_inc(x_235); +lean_dec(x_229); +x_237 = l_Lean_nullKind; +x_238 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_238, 0, x_237); +lean_ctor_set(x_238, 1, x_235); +x_239 = l_Lean_Syntax_setArg(x_1, x_22, x_238); +x_240 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_240, 0, x_239); +lean_ctor_set(x_240, 1, x_236); +return x_240; +} +} +else +{ +uint8_t x_241; +lean_dec(x_1); +x_241 = !lean_is_exclusive(x_229); if (x_241 == 0) { -lean_object* x_242; uint8_t x_243; -x_242 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; -x_243 = lean_name_eq(x_10, x_242); -if (x_243 == 0) -{ -lean_object* x_244; uint8_t x_245; -x_244 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; -x_245 = lean_name_eq(x_10, x_244); -if (x_245 == 0) -{ -lean_object* x_246; uint8_t x_247; -x_246 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_247 = lean_name_eq(x_10, x_246); -if (x_247 == 0) -{ -lean_object* x_248; uint8_t x_249; -x_248 = l_Lean_strLitKind; -x_249 = lean_name_eq(x_10, x_248); -if (x_249 == 0) -{ -lean_object* x_250; uint8_t x_251; -x_250 = l_Lean_numLitKind; -x_251 = lean_name_eq(x_10, x_250); -if (x_251 == 0) -{ -lean_object* x_252; uint8_t x_253; -x_252 = l_Lean_scientificLitKind; -x_253 = lean_name_eq(x_10, x_252); -if (x_253 == 0) -{ -lean_object* x_254; uint8_t x_255; -x_254 = l_Lean_charLitKind; -x_255 = lean_name_eq(x_10, x_254); -if (x_255 == 0) -{ -lean_object* x_256; uint8_t x_257; -lean_free_object(x_24); -x_256 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; -x_257 = lean_name_eq(x_10, x_256); -if (x_257 == 0) -{ -lean_object* x_258; uint8_t x_259; -x_258 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; -x_259 = lean_name_eq(x_10, x_258); -if (x_259 == 0) -{ -lean_object* x_260; uint8_t x_261; -lean_dec(x_1); -x_260 = l_Lean_choiceKind; -x_261 = lean_name_eq(x_10, x_260); -lean_dec(x_10); -if (x_261 == 0) -{ -lean_object* x_262; -x_262 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_231); -lean_dec(x_2); -return x_262; +return x_229; } else { -lean_object* x_263; lean_object* x_264; -x_263 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; -x_264 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_263, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_231); -lean_dec(x_2); -return x_264; +lean_object* x_242; lean_object* x_243; lean_object* x_244; +x_242 = lean_ctor_get(x_229, 0); +x_243 = lean_ctor_get(x_229, 1); +lean_inc(x_243); +lean_inc(x_242); +lean_dec(x_229); +x_244 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_244, 0, x_242); +lean_ctor_set(x_244, 1, x_243); +return x_244; +} +} } } else { -lean_object* x_265; -lean_dec(x_10); -lean_dec(x_2); -x_265 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -return x_265; -} -} -else -{ -lean_object* x_266; -lean_dec(x_10); -lean_dec(x_2); -x_266 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -return x_266; -} -} -else -{ -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -} -else -{ -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -} -else -{ -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -} -else -{ -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -} -else -{ -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -} -else -{ -lean_object* x_267; lean_object* x_268; lean_object* x_269; +lean_object* x_245; lean_free_object(x_24); lean_dec(x_10); -x_267 = lean_unsigned_to_nat(0u); -x_268 = l_Lean_Syntax_getArg(x_1, x_267); +x_245 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_1); +return x_245; +} +} +else +{ +lean_object* x_246; +lean_free_object(x_24); +lean_dec(x_10); +x_246 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_3, x_4, x_5, x_6, x_7, x_8, x_26); +return x_246; +} +} +else +{ +lean_object* x_247; lean_object* x_248; lean_object* x_249; lean_object* x_250; uint8_t x_251; uint8_t x_252; uint8_t x_253; lean_object* x_254; lean_object* x_255; lean_object* x_256; uint8_t x_257; lean_object* x_258; +x_247 = lean_ctor_get(x_3, 0); +x_248 = lean_ctor_get(x_3, 1); +x_249 = lean_ctor_get(x_3, 2); +x_250 = lean_ctor_get(x_3, 3); +x_251 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); +x_252 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); +x_253 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); +x_254 = lean_ctor_get(x_3, 5); +x_255 = lean_ctor_get(x_3, 6); +x_256 = lean_ctor_get(x_3, 7); +x_257 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); +lean_inc(x_256); +lean_inc(x_255); +lean_inc(x_254); +lean_inc(x_250); +lean_inc(x_249); +lean_inc(x_248); +lean_inc(x_247); +lean_dec(x_3); +x_258 = lean_alloc_ctor(0, 8, 4); +lean_ctor_set(x_258, 0, x_247); +lean_ctor_set(x_258, 1, x_248); +lean_ctor_set(x_258, 2, x_249); +lean_ctor_set(x_258, 3, x_250); +lean_ctor_set(x_258, 4, x_21); +lean_ctor_set(x_258, 5, x_254); +lean_ctor_set(x_258, 6, x_255); +lean_ctor_set(x_258, 7, x_256); +lean_ctor_set_uint8(x_258, sizeof(void*)*8, x_251); +lean_ctor_set_uint8(x_258, sizeof(void*)*8 + 1, x_252); +lean_ctor_set_uint8(x_258, sizeof(void*)*8 + 2, x_253); +lean_ctor_set_uint8(x_258, sizeof(void*)*8 + 3, x_257); +if (x_17 == 0) +{ +lean_object* x_259; uint8_t x_260; +x_259 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; +x_260 = lean_name_eq(x_10, x_259); +if (x_260 == 0) +{ +lean_object* x_261; uint8_t x_262; +x_261 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_262 = lean_name_eq(x_10, x_261); +if (x_262 == 0) +{ +lean_object* x_263; uint8_t x_264; +x_263 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; +x_264 = lean_name_eq(x_10, x_263); +if (x_264 == 0) +{ +lean_object* x_265; uint8_t x_266; +x_265 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; +x_266 = lean_name_eq(x_10, x_265); +if (x_266 == 0) +{ +lean_object* x_267; uint8_t x_268; +x_267 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; +x_268 = lean_name_eq(x_10, x_267); +if (x_268 == 0) +{ +lean_object* x_269; uint8_t x_270; +x_269 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_270 = lean_name_eq(x_10, x_269); +if (x_270 == 0) +{ +lean_object* x_271; uint8_t x_272; +x_271 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; +x_272 = lean_name_eq(x_10, x_271); +if (x_272 == 0) +{ +lean_object* x_273; uint8_t x_274; +x_273 = l_Lean_Parser_Term_binop___elambda__1___closed__2; +x_274 = lean_name_eq(x_10, x_273); +if (x_274 == 0) +{ +lean_object* x_275; uint8_t x_276; +x_275 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_276 = lean_name_eq(x_10, x_275); +if (x_276 == 0) +{ +lean_object* x_277; uint8_t x_278; +x_277 = l_Lean_strLitKind; +x_278 = lean_name_eq(x_10, x_277); +if (x_278 == 0) +{ +lean_object* x_279; uint8_t x_280; +x_279 = l_Lean_numLitKind; +x_280 = lean_name_eq(x_10, x_279); +if (x_280 == 0) +{ +lean_object* x_281; uint8_t x_282; +x_281 = l_Lean_scientificLitKind; +x_282 = lean_name_eq(x_10, x_281); +if (x_282 == 0) +{ +lean_object* x_283; uint8_t x_284; +x_283 = l_Lean_charLitKind; +x_284 = lean_name_eq(x_10, x_283); +if (x_284 == 0) +{ +lean_object* x_285; uint8_t x_286; +lean_free_object(x_24); +x_285 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_286 = lean_name_eq(x_10, x_285); +if (x_286 == 0) +{ +lean_object* x_287; uint8_t x_288; +x_287 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; +x_288 = lean_name_eq(x_10, x_287); +if (x_288 == 0) +{ +lean_object* x_289; uint8_t x_290; +lean_dec(x_1); +x_289 = l_Lean_choiceKind; +x_290 = lean_name_eq(x_10, x_289); +lean_dec(x_10); +if (x_290 == 0) +{ +lean_object* x_291; +x_291 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_258); +lean_dec(x_2); +return x_291; +} +else +{ +lean_object* x_292; lean_object* x_293; +x_292 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; +x_293 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_292, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_258); +lean_dec(x_2); +return x_293; +} +} +else +{ +lean_object* x_294; +lean_dec(x_10); +lean_dec(x_2); +x_294 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_294; +} +} +else +{ +lean_object* x_295; +lean_dec(x_10); +lean_dec(x_2); +x_295 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_295; +} +} +else +{ +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +else +{ +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +else +{ +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +else +{ +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +else +{ +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +else +{ +lean_object* x_296; lean_object* x_297; lean_object* x_298; +lean_free_object(x_24); +lean_dec(x_10); +x_296 = lean_unsigned_to_nat(2u); +x_297 = l_Lean_Syntax_getArg(x_1, x_296); +lean_inc(x_8); lean_inc(x_7); -lean_inc(x_268); -x_269 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_268, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -if (lean_obj_tag(x_269) == 0) +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_258); +lean_inc(x_2); +x_298 = l_Lean_Elab_Term_CollectPatternVars_collect(x_297, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_298) == 0) { -lean_object* x_270; lean_object* x_271; lean_object* x_272; lean_object* x_273; -x_270 = lean_ctor_get(x_269, 1); -lean_inc(x_270); -lean_dec(x_269); -x_271 = lean_unsigned_to_nat(2u); -x_272 = l_Lean_Syntax_getArg(x_1, x_271); +lean_object* x_299; lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; +x_299 = lean_ctor_get(x_298, 0); +lean_inc(x_299); +x_300 = lean_ctor_get(x_298, 1); +lean_inc(x_300); +lean_dec(x_298); +x_301 = lean_unsigned_to_nat(3u); +x_302 = l_Lean_Syntax_getArg(x_1, x_301); +x_303 = l_Lean_Elab_Term_CollectPatternVars_collect(x_302, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_300); +if (lean_obj_tag(x_303) == 0) +{ +lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; lean_object* x_308; lean_object* x_309; +x_304 = lean_ctor_get(x_303, 0); +lean_inc(x_304); +x_305 = lean_ctor_get(x_303, 1); +lean_inc(x_305); +if (lean_is_exclusive(x_303)) { + lean_ctor_release(x_303, 0); + lean_ctor_release(x_303, 1); + x_306 = x_303; +} else { + lean_dec_ref(x_303); + x_306 = lean_box(0); +} +x_307 = l_Lean_Syntax_setArg(x_1, x_296, x_299); +x_308 = l_Lean_Syntax_setArg(x_307, x_301, x_304); +if (lean_is_scalar(x_306)) { + x_309 = lean_alloc_ctor(0, 2, 0); +} else { + x_309 = x_306; +} +lean_ctor_set(x_309, 0, x_308); +lean_ctor_set(x_309, 1, x_305); +return x_309; +} +else +{ +lean_object* x_310; lean_object* x_311; lean_object* x_312; lean_object* x_313; +lean_dec(x_299); +lean_dec(x_1); +x_310 = lean_ctor_get(x_303, 0); +lean_inc(x_310); +x_311 = lean_ctor_get(x_303, 1); +lean_inc(x_311); +if (lean_is_exclusive(x_303)) { + lean_ctor_release(x_303, 0); + lean_ctor_release(x_303, 1); + x_312 = x_303; +} else { + lean_dec_ref(x_303); + x_312 = lean_box(0); +} +if (lean_is_scalar(x_312)) { + x_313 = lean_alloc_ctor(1, 2, 0); +} else { + x_313 = x_312; +} +lean_ctor_set(x_313, 0, x_310); +lean_ctor_set(x_313, 1, x_311); +return x_313; +} +} +else +{ +lean_object* x_314; lean_object* x_315; lean_object* x_316; lean_object* x_317; +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_314 = lean_ctor_get(x_298, 0); +lean_inc(x_314); +x_315 = lean_ctor_get(x_298, 1); +lean_inc(x_315); +if (lean_is_exclusive(x_298)) { + lean_ctor_release(x_298, 0); + lean_ctor_release(x_298, 1); + x_316 = x_298; +} else { + lean_dec_ref(x_298); + x_316 = lean_box(0); +} +if (lean_is_scalar(x_316)) { + x_317 = lean_alloc_ctor(1, 2, 0); +} else { + x_317 = x_316; +} +lean_ctor_set(x_317, 0, x_314); +lean_ctor_set(x_317, 1, x_315); +return x_317; +} +} +} +else +{ +lean_object* x_318; lean_object* x_319; lean_object* x_320; +lean_free_object(x_24); +lean_dec(x_10); +x_318 = lean_unsigned_to_nat(0u); +x_319 = l_Lean_Syntax_getArg(x_1, x_318); +lean_inc(x_7); +lean_inc(x_319); +x_320 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_319, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_320) == 0) +{ +lean_object* x_321; lean_object* x_322; lean_object* x_323; lean_object* x_324; +x_321 = lean_ctor_get(x_320, 1); +lean_inc(x_321); +lean_dec(x_320); +x_322 = lean_unsigned_to_nat(2u); +x_323 = l_Lean_Syntax_getArg(x_1, x_322); lean_dec(x_1); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); lean_inc(x_4); -lean_inc(x_231); -x_273 = l_Lean_Elab_Term_CollectPatternVars_collect(x_272, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_270); -if (lean_obj_tag(x_273) == 0) +lean_inc(x_258); +x_324 = l_Lean_Elab_Term_CollectPatternVars_collect(x_323, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_321); +if (lean_obj_tag(x_324) == 0) { -lean_object* x_274; lean_object* x_275; lean_object* x_276; lean_object* x_277; lean_object* x_278; lean_object* x_279; lean_object* x_280; lean_object* x_281; lean_object* x_282; lean_object* x_283; lean_object* x_284; lean_object* x_285; lean_object* x_286; lean_object* x_287; lean_object* x_288; lean_object* x_289; lean_object* x_290; lean_object* x_291; lean_object* x_292; lean_object* x_293; lean_object* x_294; lean_object* x_295; lean_object* x_296; lean_object* x_297; lean_object* x_298; lean_object* x_299; -x_274 = lean_ctor_get(x_273, 0); -lean_inc(x_274); -x_275 = lean_ctor_get(x_273, 1); -lean_inc(x_275); -lean_dec(x_273); -x_276 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_275); -x_277 = lean_ctor_get(x_276, 0); -lean_inc(x_277); -x_278 = lean_ctor_get(x_276, 1); -lean_inc(x_278); -lean_dec(x_276); -x_279 = l_Lean_Elab_Term_getCurrMacroScope(x_231, x_4, x_5, x_6, x_7, x_8, x_278); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_231); -x_280 = lean_ctor_get(x_279, 0); -lean_inc(x_280); -x_281 = lean_ctor_get(x_279, 1); -lean_inc(x_281); -lean_dec(x_279); -x_282 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_281); -lean_dec(x_8); -x_283 = lean_ctor_get(x_282, 0); -lean_inc(x_283); -x_284 = lean_ctor_get(x_282, 1); -lean_inc(x_284); -if (lean_is_exclusive(x_282)) { - lean_ctor_release(x_282, 0); - lean_ctor_release(x_282, 1); - x_285 = x_282; -} else { - lean_dec_ref(x_282); - x_285 = lean_box(0); -} -x_286 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; -x_287 = l_Lean_addMacroScope(x_283, x_286, x_280); -x_288 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; -x_289 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; -x_290 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_290, 0, x_277); -lean_ctor_set(x_290, 1, x_288); -lean_ctor_set(x_290, 2, x_287); -lean_ctor_set(x_290, 3, x_289); -x_291 = l_Array_empty___closed__1; -x_292 = lean_array_push(x_291, x_290); -x_293 = lean_array_push(x_291, x_268); -x_294 = lean_array_push(x_293, x_274); -x_295 = l_Lean_nullKind___closed__2; -x_296 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_296, 0, x_295); -lean_ctor_set(x_296, 1, x_294); -x_297 = lean_array_push(x_292, x_296); -x_298 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_298, 0, x_232); -lean_ctor_set(x_298, 1, x_297); -if (lean_is_scalar(x_285)) { - x_299 = lean_alloc_ctor(0, 2, 0); -} else { - x_299 = x_285; -} -lean_ctor_set(x_299, 0, x_298); -lean_ctor_set(x_299, 1, x_284); -return x_299; -} -else -{ -lean_object* x_300; lean_object* x_301; lean_object* x_302; lean_object* x_303; -lean_dec(x_268); -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -x_300 = lean_ctor_get(x_273, 0); -lean_inc(x_300); -x_301 = lean_ctor_get(x_273, 1); -lean_inc(x_301); -if (lean_is_exclusive(x_273)) { - lean_ctor_release(x_273, 0); - lean_ctor_release(x_273, 1); - x_302 = x_273; -} else { - lean_dec_ref(x_273); - x_302 = lean_box(0); -} -if (lean_is_scalar(x_302)) { - x_303 = lean_alloc_ctor(1, 2, 0); -} else { - x_303 = x_302; -} -lean_ctor_set(x_303, 0, x_300); -lean_ctor_set(x_303, 1, x_301); -return x_303; -} -} -else -{ -lean_object* x_304; lean_object* x_305; lean_object* x_306; lean_object* x_307; -lean_dec(x_268); -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_304 = lean_ctor_get(x_269, 0); -lean_inc(x_304); -x_305 = lean_ctor_get(x_269, 1); -lean_inc(x_305); -if (lean_is_exclusive(x_269)) { - lean_ctor_release(x_269, 0); - lean_ctor_release(x_269, 1); - x_306 = x_269; -} else { - lean_dec_ref(x_269); - x_306 = lean_box(0); -} -if (lean_is_scalar(x_306)) { - x_307 = lean_alloc_ctor(1, 2, 0); -} else { - x_307 = x_306; -} -lean_ctor_set(x_307, 0, x_304); -lean_ctor_set(x_307, 1, x_305); -return x_307; -} -} -} -else -{ -lean_object* x_308; lean_object* x_309; lean_object* x_310; -lean_free_object(x_24); -lean_dec(x_10); -x_308 = lean_unsigned_to_nat(0u); -x_309 = l_Lean_Syntax_getArg(x_1, x_308); -lean_dec(x_1); -x_310 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_309, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -return x_310; -} -} -else -{ -lean_object* x_311; uint8_t x_312; -lean_dec(x_10); -x_311 = l_Lean_Syntax_getArg(x_1, x_22); -x_312 = l_Lean_Syntax_isNone(x_311); -if (x_312 == 0) -{ -lean_object* x_313; lean_object* x_314; lean_object* x_315; uint8_t x_316; -x_313 = lean_unsigned_to_nat(0u); -x_314 = l_Lean_Syntax_getArg(x_311, x_313); -x_315 = l_Lean_Syntax_getArg(x_311, x_22); -x_316 = l_Lean_Syntax_isNone(x_315); -if (x_316 == 0) -{ -lean_object* x_317; lean_object* x_318; lean_object* x_319; uint8_t x_320; -x_317 = l_Lean_Syntax_getArg(x_315, x_313); -lean_dec(x_315); -x_318 = l_Lean_Syntax_getKind(x_317); -x_319 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; -x_320 = lean_name_eq(x_318, x_319); -lean_dec(x_318); -if (x_320 == 0) -{ -lean_dec(x_314); -lean_dec(x_311); -lean_dec(x_231); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -else -{ -lean_object* x_321; -lean_free_object(x_24); -x_321 = l_Lean_Elab_Term_CollectPatternVars_collect(x_314, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -if (lean_obj_tag(x_321) == 0) -{ -lean_object* x_322; lean_object* x_323; lean_object* x_324; lean_object* x_325; lean_object* x_326; lean_object* x_327; -x_322 = lean_ctor_get(x_321, 0); -lean_inc(x_322); -x_323 = lean_ctor_get(x_321, 1); -lean_inc(x_323); -if (lean_is_exclusive(x_321)) { - lean_ctor_release(x_321, 0); - lean_ctor_release(x_321, 1); - x_324 = x_321; -} else { - lean_dec_ref(x_321); - x_324 = lean_box(0); -} -x_325 = l_Lean_Syntax_setArg(x_311, x_313, x_322); -x_326 = l_Lean_Syntax_setArg(x_1, x_22, x_325); -if (lean_is_scalar(x_324)) { - x_327 = lean_alloc_ctor(0, 2, 0); -} else { - x_327 = x_324; -} -lean_ctor_set(x_327, 0, x_326); -lean_ctor_set(x_327, 1, x_323); -return x_327; -} -else -{ -lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; -lean_dec(x_311); -lean_dec(x_1); -x_328 = lean_ctor_get(x_321, 0); +lean_object* x_325; lean_object* x_326; lean_object* x_327; lean_object* x_328; lean_object* x_329; lean_object* x_330; lean_object* x_331; lean_object* x_332; lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; +x_325 = lean_ctor_get(x_324, 0); +lean_inc(x_325); +x_326 = lean_ctor_get(x_324, 1); +lean_inc(x_326); +lean_dec(x_324); +x_327 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_326); +x_328 = lean_ctor_get(x_327, 0); lean_inc(x_328); -x_329 = lean_ctor_get(x_321, 1); +x_329 = lean_ctor_get(x_327, 1); lean_inc(x_329); -if (lean_is_exclusive(x_321)) { - lean_ctor_release(x_321, 0); - lean_ctor_release(x_321, 1); - x_330 = x_321; -} else { - lean_dec_ref(x_321); - x_330 = lean_box(0); -} -if (lean_is_scalar(x_330)) { - x_331 = lean_alloc_ctor(1, 2, 0); -} else { - x_331 = x_330; -} -lean_ctor_set(x_331, 0, x_328); -lean_ctor_set(x_331, 1, x_329); -return x_331; -} -} -} -else -{ -lean_object* x_332; -lean_dec(x_315); -lean_free_object(x_24); -x_332 = l_Lean_Elab_Term_CollectPatternVars_collect(x_314, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -if (lean_obj_tag(x_332) == 0) -{ -lean_object* x_333; lean_object* x_334; lean_object* x_335; lean_object* x_336; lean_object* x_337; lean_object* x_338; -x_333 = lean_ctor_get(x_332, 0); -lean_inc(x_333); -x_334 = lean_ctor_get(x_332, 1); +lean_dec(x_327); +x_330 = l_Lean_Elab_Term_getCurrMacroScope(x_258, x_4, x_5, x_6, x_7, x_8, x_329); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_258); +x_331 = lean_ctor_get(x_330, 0); +lean_inc(x_331); +x_332 = lean_ctor_get(x_330, 1); +lean_inc(x_332); +lean_dec(x_330); +x_333 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_332); +lean_dec(x_8); +x_334 = lean_ctor_get(x_333, 0); lean_inc(x_334); -if (lean_is_exclusive(x_332)) { - lean_ctor_release(x_332, 0); - lean_ctor_release(x_332, 1); - x_335 = x_332; +x_335 = lean_ctor_get(x_333, 1); +lean_inc(x_335); +if (lean_is_exclusive(x_333)) { + lean_ctor_release(x_333, 0); + lean_ctor_release(x_333, 1); + x_336 = x_333; } else { - lean_dec_ref(x_332); - x_335 = lean_box(0); + lean_dec_ref(x_333); + x_336 = lean_box(0); } -x_336 = l_Lean_Syntax_setArg(x_311, x_313, x_333); -x_337 = l_Lean_Syntax_setArg(x_1, x_22, x_336); -if (lean_is_scalar(x_335)) { - x_338 = lean_alloc_ctor(0, 2, 0); +x_337 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; +x_338 = l_Lean_addMacroScope(x_334, x_337, x_331); +x_339 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; +x_340 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; +x_341 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_341, 0, x_328); +lean_ctor_set(x_341, 1, x_339); +lean_ctor_set(x_341, 2, x_338); +lean_ctor_set(x_341, 3, x_340); +x_342 = l_Array_empty___closed__1; +x_343 = lean_array_push(x_342, x_341); +x_344 = lean_array_push(x_342, x_319); +x_345 = lean_array_push(x_344, x_325); +x_346 = l_Lean_nullKind___closed__2; +x_347 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_347, 0, x_346); +lean_ctor_set(x_347, 1, x_345); +x_348 = lean_array_push(x_343, x_347); +x_349 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_349, 0, x_259); +lean_ctor_set(x_349, 1, x_348); +if (lean_is_scalar(x_336)) { + x_350 = lean_alloc_ctor(0, 2, 0); } else { - x_338 = x_335; + x_350 = x_336; } -lean_ctor_set(x_338, 0, x_337); -lean_ctor_set(x_338, 1, x_334); -return x_338; +lean_ctor_set(x_350, 0, x_349); +lean_ctor_set(x_350, 1, x_335); +return x_350; } else { -lean_object* x_339; lean_object* x_340; lean_object* x_341; lean_object* x_342; -lean_dec(x_311); -lean_dec(x_1); -x_339 = lean_ctor_get(x_332, 0); -lean_inc(x_339); -x_340 = lean_ctor_get(x_332, 1); -lean_inc(x_340); -if (lean_is_exclusive(x_332)) { - lean_ctor_release(x_332, 0); - lean_ctor_release(x_332, 1); - x_341 = x_332; -} else { - lean_dec_ref(x_332); - x_341 = lean_box(0); -} -if (lean_is_scalar(x_341)) { - x_342 = lean_alloc_ctor(1, 2, 0); -} else { - x_342 = x_341; -} -lean_ctor_set(x_342, 0, x_339); -lean_ctor_set(x_342, 1, x_340); -return x_342; -} -} -} -else -{ -lean_dec(x_311); -lean_dec(x_231); +lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; +lean_dec(x_319); +lean_dec(x_258); lean_dec(x_7); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_2); -lean_ctor_set(x_24, 0, x_1); -return x_24; -} -} -} -else -{ -lean_object* x_343; lean_object* x_344; lean_object* x_345; lean_object* x_346; lean_object* x_347; lean_object* x_348; lean_object* x_349; lean_object* x_350; lean_object* x_351; lean_object* x_352; lean_object* x_353; lean_object* x_354; lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; lean_object* x_359; lean_object* x_360; lean_object* x_361; -lean_dec(x_231); -lean_free_object(x_24); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -x_343 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_26); -x_344 = lean_ctor_get(x_343, 0); -lean_inc(x_344); -x_345 = lean_ctor_get(x_343, 1); -lean_inc(x_345); -lean_dec(x_343); -x_346 = lean_st_ref_get(x_8, x_345); -lean_dec(x_8); -x_347 = lean_ctor_get(x_346, 1); -lean_inc(x_347); -lean_dec(x_346); -x_348 = lean_st_ref_take(x_2, x_347); -x_349 = lean_ctor_get(x_348, 0); -lean_inc(x_349); -x_350 = lean_ctor_get(x_348, 1); -lean_inc(x_350); -lean_dec(x_348); -x_351 = lean_ctor_get(x_349, 0); +x_351 = lean_ctor_get(x_324, 0); lean_inc(x_351); -x_352 = lean_ctor_get(x_349, 1); +x_352 = lean_ctor_get(x_324, 1); lean_inc(x_352); -if (lean_is_exclusive(x_349)) { - lean_ctor_release(x_349, 0); - lean_ctor_release(x_349, 1); - x_353 = x_349; +if (lean_is_exclusive(x_324)) { + lean_ctor_release(x_324, 0); + lean_ctor_release(x_324, 1); + x_353 = x_324; } else { - lean_dec_ref(x_349); + lean_dec_ref(x_324); x_353 = lean_box(0); } -x_354 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_344); -x_355 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_355, 0, x_354); -x_356 = lean_array_push(x_352, x_355); if (lean_is_scalar(x_353)) { - x_357 = lean_alloc_ctor(0, 2, 0); + x_354 = lean_alloc_ctor(1, 2, 0); } else { - x_357 = x_353; + x_354 = x_353; } -lean_ctor_set(x_357, 0, x_351); -lean_ctor_set(x_357, 1, x_356); -x_358 = lean_st_ref_set(x_2, x_357, x_350); +lean_ctor_set(x_354, 0, x_351); +lean_ctor_set(x_354, 1, x_352); +return x_354; +} +} +else +{ +lean_object* x_355; lean_object* x_356; lean_object* x_357; lean_object* x_358; +lean_dec(x_319); +lean_dec(x_258); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); lean_dec(x_2); -x_359 = lean_ctor_get(x_358, 1); -lean_inc(x_359); -if (lean_is_exclusive(x_358)) { - lean_ctor_release(x_358, 0); - lean_ctor_release(x_358, 1); - x_360 = x_358; +lean_dec(x_1); +x_355 = lean_ctor_get(x_320, 0); +lean_inc(x_355); +x_356 = lean_ctor_get(x_320, 1); +lean_inc(x_356); +if (lean_is_exclusive(x_320)) { + lean_ctor_release(x_320, 0); + lean_ctor_release(x_320, 1); + x_357 = x_320; } else { - lean_dec_ref(x_358); - x_360 = lean_box(0); + lean_dec_ref(x_320); + x_357 = lean_box(0); } -if (lean_is_scalar(x_360)) { - x_361 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_357)) { + x_358 = lean_alloc_ctor(1, 2, 0); } else { - x_361 = x_360; + x_358 = x_357; } -lean_ctor_set(x_361, 0, x_344); -lean_ctor_set(x_361, 1, x_359); +lean_ctor_set(x_358, 0, x_355); +lean_ctor_set(x_358, 1, x_356); +return x_358; +} +} +} +else +{ +lean_object* x_359; lean_object* x_360; lean_object* x_361; +lean_free_object(x_24); +lean_dec(x_10); +x_359 = lean_unsigned_to_nat(0u); +x_360 = l_Lean_Syntax_getArg(x_1, x_359); +lean_dec(x_1); +x_361 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_360, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); return x_361; } } else { lean_object* x_362; uint8_t x_363; -lean_free_object(x_24); lean_dec(x_10); x_362 = l_Lean_Syntax_getArg(x_1, x_22); x_363 = l_Lean_Syntax_isNone(x_362); if (x_363 == 0) { -lean_object* x_364; lean_object* x_365; lean_object* x_366; lean_object* x_367; lean_object* x_368; lean_object* x_369; -lean_dec(x_1); -x_364 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; -x_365 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_362, x_364, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); +lean_object* x_364; lean_object* x_365; lean_object* x_366; uint8_t x_367; +x_364 = lean_unsigned_to_nat(0u); +x_365 = l_Lean_Syntax_getArg(x_362, x_364); +x_366 = l_Lean_Syntax_getArg(x_362, x_22); +x_367 = l_Lean_Syntax_isNone(x_366); +if (x_367 == 0) +{ +lean_object* x_368; lean_object* x_369; lean_object* x_370; uint8_t x_371; +x_368 = l_Lean_Syntax_getArg(x_366, x_364); +lean_dec(x_366); +x_369 = l_Lean_Syntax_getKind(x_368); +x_370 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; +x_371 = lean_name_eq(x_369, x_370); +lean_dec(x_369); +if (x_371 == 0) +{ +lean_dec(x_365); +lean_dec(x_362); +lean_dec(x_258); +lean_dec(x_7); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_231); lean_dec(x_2); -lean_dec(x_362); -x_366 = lean_ctor_get(x_365, 0); -lean_inc(x_366); -x_367 = lean_ctor_get(x_365, 1); -lean_inc(x_367); -if (lean_is_exclusive(x_365)) { - lean_ctor_release(x_365, 0); - lean_ctor_release(x_365, 1); - x_368 = x_365; -} else { - lean_dec_ref(x_365); - x_368 = lean_box(0); -} -if (lean_is_scalar(x_368)) { - x_369 = lean_alloc_ctor(1, 2, 0); -} else { - x_369 = x_368; -} -lean_ctor_set(x_369, 0, x_366); -lean_ctor_set(x_369, 1, x_367); -return x_369; +lean_ctor_set(x_24, 0, x_1); +return x_24; } else { -lean_object* x_370; lean_object* x_371; -lean_dec(x_362); -x_370 = lean_box(0); -x_371 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_370, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -return x_371; -} -} -} -else -{ -lean_object* x_372; lean_object* x_373; lean_object* x_374; lean_object* x_375; +lean_object* x_372; lean_free_object(x_24); -lean_dec(x_10); -x_372 = l_Lean_Syntax_getArg(x_1, x_22); -x_373 = l_Lean_Syntax_getArgs(x_372); -lean_dec(x_372); -x_374 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; -x_375 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_373, x_374, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -lean_dec(x_373); -if (lean_obj_tag(x_375) == 0) +x_372 = l_Lean_Elab_Term_CollectPatternVars_collect(x_365, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_372) == 0) { -lean_object* x_376; lean_object* x_377; lean_object* x_378; lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; -x_376 = lean_ctor_get(x_375, 0); -lean_inc(x_376); -x_377 = lean_ctor_get(x_375, 1); -lean_inc(x_377); -if (lean_is_exclusive(x_375)) { - lean_ctor_release(x_375, 0); - lean_ctor_release(x_375, 1); +lean_object* x_373; lean_object* x_374; lean_object* x_375; lean_object* x_376; lean_object* x_377; lean_object* x_378; +x_373 = lean_ctor_get(x_372, 0); +lean_inc(x_373); +x_374 = lean_ctor_get(x_372, 1); +lean_inc(x_374); +if (lean_is_exclusive(x_372)) { + lean_ctor_release(x_372, 0); + lean_ctor_release(x_372, 1); + x_375 = x_372; +} else { + lean_dec_ref(x_372); + x_375 = lean_box(0); +} +x_376 = l_Lean_Syntax_setArg(x_362, x_364, x_373); +x_377 = l_Lean_Syntax_setArg(x_1, x_22, x_376); +if (lean_is_scalar(x_375)) { + x_378 = lean_alloc_ctor(0, 2, 0); +} else { x_378 = x_375; -} else { - lean_dec_ref(x_375); - x_378 = lean_box(0); } -x_379 = l_Lean_nullKind; -x_380 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_380, 0, x_379); -lean_ctor_set(x_380, 1, x_376); -x_381 = l_Lean_Syntax_setArg(x_1, x_22, x_380); -if (lean_is_scalar(x_378)) { - x_382 = lean_alloc_ctor(0, 2, 0); -} else { - x_382 = x_378; +lean_ctor_set(x_378, 0, x_377); +lean_ctor_set(x_378, 1, x_374); +return x_378; } -lean_ctor_set(x_382, 0, x_381); -lean_ctor_set(x_382, 1, x_377); +else +{ +lean_object* x_379; lean_object* x_380; lean_object* x_381; lean_object* x_382; +lean_dec(x_362); +lean_dec(x_1); +x_379 = lean_ctor_get(x_372, 0); +lean_inc(x_379); +x_380 = lean_ctor_get(x_372, 1); +lean_inc(x_380); +if (lean_is_exclusive(x_372)) { + lean_ctor_release(x_372, 0); + lean_ctor_release(x_372, 1); + x_381 = x_372; +} else { + lean_dec_ref(x_372); + x_381 = lean_box(0); +} +if (lean_is_scalar(x_381)) { + x_382 = lean_alloc_ctor(1, 2, 0); +} else { + x_382 = x_381; +} +lean_ctor_set(x_382, 0, x_379); +lean_ctor_set(x_382, 1, x_380); return x_382; } +} +} else { -lean_object* x_383; lean_object* x_384; lean_object* x_385; lean_object* x_386; -lean_dec(x_1); -x_383 = lean_ctor_get(x_375, 0); -lean_inc(x_383); -x_384 = lean_ctor_get(x_375, 1); +lean_object* x_383; +lean_dec(x_366); +lean_free_object(x_24); +x_383 = l_Lean_Elab_Term_CollectPatternVars_collect(x_365, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +if (lean_obj_tag(x_383) == 0) +{ +lean_object* x_384; lean_object* x_385; lean_object* x_386; lean_object* x_387; lean_object* x_388; lean_object* x_389; +x_384 = lean_ctor_get(x_383, 0); lean_inc(x_384); -if (lean_is_exclusive(x_375)) { - lean_ctor_release(x_375, 0); - lean_ctor_release(x_375, 1); - x_385 = x_375; +x_385 = lean_ctor_get(x_383, 1); +lean_inc(x_385); +if (lean_is_exclusive(x_383)) { + lean_ctor_release(x_383, 0); + lean_ctor_release(x_383, 1); + x_386 = x_383; } else { - lean_dec_ref(x_375); - x_385 = lean_box(0); + lean_dec_ref(x_383); + x_386 = lean_box(0); } -if (lean_is_scalar(x_385)) { - x_386 = lean_alloc_ctor(1, 2, 0); +x_387 = l_Lean_Syntax_setArg(x_362, x_364, x_384); +x_388 = l_Lean_Syntax_setArg(x_1, x_22, x_387); +if (lean_is_scalar(x_386)) { + x_389 = lean_alloc_ctor(0, 2, 0); } else { - x_386 = x_385; -} -lean_ctor_set(x_386, 0, x_383); -lean_ctor_set(x_386, 1, x_384); -return x_386; -} + x_389 = x_386; } +lean_ctor_set(x_389, 0, x_388); +lean_ctor_set(x_389, 1, x_385); +return x_389; } else { -lean_object* x_387; -lean_free_object(x_24); -lean_dec(x_10); -x_387 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); +lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; +lean_dec(x_362); lean_dec(x_1); -return x_387; -} -} -else -{ -lean_object* x_388; -lean_free_object(x_24); -lean_dec(x_10); -x_388 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_231, x_4, x_5, x_6, x_7, x_8, x_26); -return x_388; -} -} -} -else -{ -lean_object* x_389; lean_object* x_390; lean_object* x_391; lean_object* x_392; lean_object* x_393; uint8_t x_394; uint8_t x_395; uint8_t x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; uint8_t x_400; lean_object* x_401; lean_object* x_402; -x_389 = lean_ctor_get(x_24, 1); -lean_inc(x_389); -lean_dec(x_24); -x_390 = lean_ctor_get(x_3, 0); +x_390 = lean_ctor_get(x_383, 0); lean_inc(x_390); -x_391 = lean_ctor_get(x_3, 1); +x_391 = lean_ctor_get(x_383, 1); lean_inc(x_391); -x_392 = lean_ctor_get(x_3, 2); -lean_inc(x_392); -x_393 = lean_ctor_get(x_3, 3); -lean_inc(x_393); -x_394 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); -x_395 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); -x_396 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); -x_397 = lean_ctor_get(x_3, 5); -lean_inc(x_397); -x_398 = lean_ctor_get(x_3, 6); -lean_inc(x_398); -x_399 = lean_ctor_get(x_3, 7); -lean_inc(x_399); -x_400 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - lean_ctor_release(x_3, 4); - lean_ctor_release(x_3, 5); - lean_ctor_release(x_3, 6); - lean_ctor_release(x_3, 7); - x_401 = x_3; +if (lean_is_exclusive(x_383)) { + lean_ctor_release(x_383, 0); + lean_ctor_release(x_383, 1); + x_392 = x_383; } else { - lean_dec_ref(x_3); - x_401 = lean_box(0); + lean_dec_ref(x_383); + x_392 = lean_box(0); } -if (lean_is_scalar(x_401)) { - x_402 = lean_alloc_ctor(0, 8, 4); +if (lean_is_scalar(x_392)) { + x_393 = lean_alloc_ctor(1, 2, 0); } else { - x_402 = x_401; + x_393 = x_392; } -lean_ctor_set(x_402, 0, x_390); -lean_ctor_set(x_402, 1, x_391); -lean_ctor_set(x_402, 2, x_392); -lean_ctor_set(x_402, 3, x_393); -lean_ctor_set(x_402, 4, x_21); -lean_ctor_set(x_402, 5, x_397); -lean_ctor_set(x_402, 6, x_398); -lean_ctor_set(x_402, 7, x_399); -lean_ctor_set_uint8(x_402, sizeof(void*)*8, x_394); -lean_ctor_set_uint8(x_402, sizeof(void*)*8 + 1, x_395); -lean_ctor_set_uint8(x_402, sizeof(void*)*8 + 2, x_396); -lean_ctor_set_uint8(x_402, sizeof(void*)*8 + 3, x_400); -if (x_17 == 0) +lean_ctor_set(x_393, 0, x_390); +lean_ctor_set(x_393, 1, x_391); +return x_393; +} +} +} +else { -lean_object* x_403; uint8_t x_404; -x_403 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; -x_404 = lean_name_eq(x_10, x_403); -if (x_404 == 0) -{ -lean_object* x_405; uint8_t x_406; -x_405 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_406 = lean_name_eq(x_10, x_405); -if (x_406 == 0) -{ -lean_object* x_407; uint8_t x_408; -x_407 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; -x_408 = lean_name_eq(x_10, x_407); -if (x_408 == 0) -{ -lean_object* x_409; uint8_t x_410; -x_409 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; -x_410 = lean_name_eq(x_10, x_409); -if (x_410 == 0) -{ -lean_object* x_411; uint8_t x_412; -x_411 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; -x_412 = lean_name_eq(x_10, x_411); -if (x_412 == 0) -{ -lean_object* x_413; uint8_t x_414; -x_413 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; -x_414 = lean_name_eq(x_10, x_413); -if (x_414 == 0) -{ -lean_object* x_415; uint8_t x_416; -x_415 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; -x_416 = lean_name_eq(x_10, x_415); -if (x_416 == 0) -{ -lean_object* x_417; uint8_t x_418; -x_417 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_418 = lean_name_eq(x_10, x_417); -if (x_418 == 0) -{ -lean_object* x_419; uint8_t x_420; -x_419 = l_Lean_strLitKind; -x_420 = lean_name_eq(x_10, x_419); -if (x_420 == 0) -{ -lean_object* x_421; uint8_t x_422; -x_421 = l_Lean_numLitKind; -x_422 = lean_name_eq(x_10, x_421); -if (x_422 == 0) -{ -lean_object* x_423; uint8_t x_424; -x_423 = l_Lean_scientificLitKind; -x_424 = lean_name_eq(x_10, x_423); -if (x_424 == 0) -{ -lean_object* x_425; uint8_t x_426; -x_425 = l_Lean_charLitKind; -x_426 = lean_name_eq(x_10, x_425); -if (x_426 == 0) -{ -lean_object* x_427; uint8_t x_428; -x_427 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; -x_428 = lean_name_eq(x_10, x_427); -if (x_428 == 0) -{ -lean_object* x_429; uint8_t x_430; -x_429 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; -x_430 = lean_name_eq(x_10, x_429); -if (x_430 == 0) -{ -lean_object* x_431; uint8_t x_432; -lean_dec(x_1); -x_431 = l_Lean_choiceKind; -x_432 = lean_name_eq(x_10, x_431); -lean_dec(x_10); -if (x_432 == 0) -{ -lean_object* x_433; -x_433 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -lean_dec(x_8); +lean_dec(x_362); +lean_dec(x_258); lean_dec(x_7); +lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_402); lean_dec(x_2); +lean_ctor_set(x_24, 0, x_1); +return x_24; +} +} +} +else +{ +lean_object* x_394; lean_object* x_395; lean_object* x_396; lean_object* x_397; lean_object* x_398; lean_object* x_399; lean_object* x_400; lean_object* x_401; lean_object* x_402; lean_object* x_403; lean_object* x_404; lean_object* x_405; lean_object* x_406; lean_object* x_407; lean_object* x_408; lean_object* x_409; lean_object* x_410; lean_object* x_411; lean_object* x_412; +lean_dec(x_258); +lean_free_object(x_24); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_394 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_26); +x_395 = lean_ctor_get(x_394, 0); +lean_inc(x_395); +x_396 = lean_ctor_get(x_394, 1); +lean_inc(x_396); +lean_dec(x_394); +x_397 = lean_st_ref_get(x_8, x_396); +lean_dec(x_8); +x_398 = lean_ctor_get(x_397, 1); +lean_inc(x_398); +lean_dec(x_397); +x_399 = lean_st_ref_take(x_2, x_398); +x_400 = lean_ctor_get(x_399, 0); +lean_inc(x_400); +x_401 = lean_ctor_get(x_399, 1); +lean_inc(x_401); +lean_dec(x_399); +x_402 = lean_ctor_get(x_400, 0); +lean_inc(x_402); +x_403 = lean_ctor_get(x_400, 1); +lean_inc(x_403); +if (lean_is_exclusive(x_400)) { + lean_ctor_release(x_400, 0); + lean_ctor_release(x_400, 1); + x_404 = x_400; +} else { + lean_dec_ref(x_400); + x_404 = lean_box(0); +} +x_405 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_395); +x_406 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_406, 0, x_405); +x_407 = lean_array_push(x_403, x_406); +if (lean_is_scalar(x_404)) { + x_408 = lean_alloc_ctor(0, 2, 0); +} else { + x_408 = x_404; +} +lean_ctor_set(x_408, 0, x_402); +lean_ctor_set(x_408, 1, x_407); +x_409 = lean_st_ref_set(x_2, x_408, x_401); +lean_dec(x_2); +x_410 = lean_ctor_get(x_409, 1); +lean_inc(x_410); +if (lean_is_exclusive(x_409)) { + lean_ctor_release(x_409, 0); + lean_ctor_release(x_409, 1); + x_411 = x_409; +} else { + lean_dec_ref(x_409); + x_411 = lean_box(0); +} +if (lean_is_scalar(x_411)) { + x_412 = lean_alloc_ctor(0, 2, 0); +} else { + x_412 = x_411; +} +lean_ctor_set(x_412, 0, x_395); +lean_ctor_set(x_412, 1, x_410); +return x_412; +} +} +else +{ +lean_object* x_413; uint8_t x_414; +lean_free_object(x_24); +lean_dec(x_10); +x_413 = l_Lean_Syntax_getArg(x_1, x_22); +x_414 = l_Lean_Syntax_isNone(x_413); +if (x_414 == 0) +{ +lean_object* x_415; lean_object* x_416; lean_object* x_417; lean_object* x_418; lean_object* x_419; lean_object* x_420; +lean_dec(x_1); +x_415 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; +x_416 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_413, x_415, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_258); +lean_dec(x_2); +lean_dec(x_413); +x_417 = lean_ctor_get(x_416, 0); +lean_inc(x_417); +x_418 = lean_ctor_get(x_416, 1); +lean_inc(x_418); +if (lean_is_exclusive(x_416)) { + lean_ctor_release(x_416, 0); + lean_ctor_release(x_416, 1); + x_419 = x_416; +} else { + lean_dec_ref(x_416); + x_419 = lean_box(0); +} +if (lean_is_scalar(x_419)) { + x_420 = lean_alloc_ctor(1, 2, 0); +} else { + x_420 = x_419; +} +lean_ctor_set(x_420, 0, x_417); +lean_ctor_set(x_420, 1, x_418); +return x_420; +} +else +{ +lean_object* x_421; lean_object* x_422; +lean_dec(x_413); +x_421 = lean_box(0); +x_422 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_421, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +return x_422; +} +} +} +else +{ +lean_object* x_423; lean_object* x_424; lean_object* x_425; lean_object* x_426; +lean_free_object(x_24); +lean_dec(x_10); +x_423 = l_Lean_Syntax_getArg(x_1, x_22); +x_424 = l_Lean_Syntax_getArgs(x_423); +lean_dec(x_423); +x_425 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; +x_426 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_424, x_425, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_424); +if (lean_obj_tag(x_426) == 0) +{ +lean_object* x_427; lean_object* x_428; lean_object* x_429; lean_object* x_430; lean_object* x_431; lean_object* x_432; lean_object* x_433; +x_427 = lean_ctor_get(x_426, 0); +lean_inc(x_427); +x_428 = lean_ctor_get(x_426, 1); +lean_inc(x_428); +if (lean_is_exclusive(x_426)) { + lean_ctor_release(x_426, 0); + lean_ctor_release(x_426, 1); + x_429 = x_426; +} else { + lean_dec_ref(x_426); + x_429 = lean_box(0); +} +x_430 = l_Lean_nullKind; +x_431 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_431, 0, x_430); +lean_ctor_set(x_431, 1, x_427); +x_432 = l_Lean_Syntax_setArg(x_1, x_22, x_431); +if (lean_is_scalar(x_429)) { + x_433 = lean_alloc_ctor(0, 2, 0); +} else { + x_433 = x_429; +} +lean_ctor_set(x_433, 0, x_432); +lean_ctor_set(x_433, 1, x_428); return x_433; } else { -lean_object* x_434; lean_object* x_435; -x_434 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; -x_435 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_434, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_402); -lean_dec(x_2); -return x_435; -} -} -else -{ -lean_object* x_436; -lean_dec(x_10); -lean_dec(x_2); -x_436 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); +lean_object* x_434; lean_object* x_435; lean_object* x_436; lean_object* x_437; lean_dec(x_1); -return x_436; +x_434 = lean_ctor_get(x_426, 0); +lean_inc(x_434); +x_435 = lean_ctor_get(x_426, 1); +lean_inc(x_435); +if (lean_is_exclusive(x_426)) { + lean_ctor_release(x_426, 0); + lean_ctor_release(x_426, 1); + x_436 = x_426; +} else { + lean_dec_ref(x_426); + x_436 = lean_box(0); } +if (lean_is_scalar(x_436)) { + x_437 = lean_alloc_ctor(1, 2, 0); +} else { + x_437 = x_436; } -else -{ -lean_object* x_437; -lean_dec(x_10); -lean_dec(x_2); -x_437 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); +lean_ctor_set(x_437, 0, x_434); +lean_ctor_set(x_437, 1, x_435); return x_437; } } +} else { lean_object* x_438; -lean_dec(x_402); -lean_dec(x_7); +lean_free_object(x_24); lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -x_438 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_438, 0, x_1); -lean_ctor_set(x_438, 1, x_389); +x_438 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); +lean_dec(x_1); return x_438; } } else { lean_object* x_439; -lean_dec(x_402); -lean_dec(x_7); +lean_free_object(x_24); lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -x_439 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_439, 0, x_1); -lean_ctor_set(x_439, 1, x_389); +x_439 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_258, x_4, x_5, x_6, x_7, x_8, x_26); return x_439; } } -else -{ -lean_object* x_440; -lean_dec(x_402); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -x_440 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_440, 0, x_1); -lean_ctor_set(x_440, 1, x_389); -return x_440; -} } else { -lean_object* x_441; -lean_dec(x_402); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -x_441 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_441, 0, x_1); -lean_ctor_set(x_441, 1, x_389); -return x_441; -} -} -else -{ -lean_object* x_442; -lean_dec(x_402); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -x_442 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_442, 0, x_1); -lean_ctor_set(x_442, 1, x_389); -return x_442; -} -} -else -{ -lean_object* x_443; lean_object* x_444; lean_object* x_445; -lean_dec(x_10); -x_443 = lean_unsigned_to_nat(0u); -x_444 = l_Lean_Syntax_getArg(x_1, x_443); -lean_inc(x_7); +lean_object* x_440; lean_object* x_441; lean_object* x_442; lean_object* x_443; lean_object* x_444; uint8_t x_445; uint8_t x_446; uint8_t x_447; lean_object* x_448; lean_object* x_449; lean_object* x_450; uint8_t x_451; lean_object* x_452; lean_object* x_453; +x_440 = lean_ctor_get(x_24, 1); +lean_inc(x_440); +lean_dec(x_24); +x_441 = lean_ctor_get(x_3, 0); +lean_inc(x_441); +x_442 = lean_ctor_get(x_3, 1); +lean_inc(x_442); +x_443 = lean_ctor_get(x_3, 2); +lean_inc(x_443); +x_444 = lean_ctor_get(x_3, 3); lean_inc(x_444); -x_445 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_444, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -if (lean_obj_tag(x_445) == 0) +x_445 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); +x_446 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); +x_447 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); +x_448 = lean_ctor_get(x_3, 5); +lean_inc(x_448); +x_449 = lean_ctor_get(x_3, 6); +lean_inc(x_449); +x_450 = lean_ctor_get(x_3, 7); +lean_inc(x_450); +x_451 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + lean_ctor_release(x_3, 2); + lean_ctor_release(x_3, 3); + lean_ctor_release(x_3, 4); + lean_ctor_release(x_3, 5); + lean_ctor_release(x_3, 6); + lean_ctor_release(x_3, 7); + x_452 = x_3; +} else { + lean_dec_ref(x_3); + x_452 = lean_box(0); +} +if (lean_is_scalar(x_452)) { + x_453 = lean_alloc_ctor(0, 8, 4); +} else { + x_453 = x_452; +} +lean_ctor_set(x_453, 0, x_441); +lean_ctor_set(x_453, 1, x_442); +lean_ctor_set(x_453, 2, x_443); +lean_ctor_set(x_453, 3, x_444); +lean_ctor_set(x_453, 4, x_21); +lean_ctor_set(x_453, 5, x_448); +lean_ctor_set(x_453, 6, x_449); +lean_ctor_set(x_453, 7, x_450); +lean_ctor_set_uint8(x_453, sizeof(void*)*8, x_445); +lean_ctor_set_uint8(x_453, sizeof(void*)*8 + 1, x_446); +lean_ctor_set_uint8(x_453, sizeof(void*)*8 + 2, x_447); +lean_ctor_set_uint8(x_453, sizeof(void*)*8 + 3, x_451); +if (x_17 == 0) { -lean_object* x_446; lean_object* x_447; lean_object* x_448; lean_object* x_449; -x_446 = lean_ctor_get(x_445, 1); -lean_inc(x_446); -lean_dec(x_445); -x_447 = lean_unsigned_to_nat(2u); -x_448 = l_Lean_Syntax_getArg(x_1, x_447); +lean_object* x_454; uint8_t x_455; +x_454 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; +x_455 = lean_name_eq(x_10, x_454); +if (x_455 == 0) +{ +lean_object* x_456; uint8_t x_457; +x_456 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_457 = lean_name_eq(x_10, x_456); +if (x_457 == 0) +{ +lean_object* x_458; uint8_t x_459; +x_458 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; +x_459 = lean_name_eq(x_10, x_458); +if (x_459 == 0) +{ +lean_object* x_460; uint8_t x_461; +x_460 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; +x_461 = lean_name_eq(x_10, x_460); +if (x_461 == 0) +{ +lean_object* x_462; uint8_t x_463; +x_462 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; +x_463 = lean_name_eq(x_10, x_462); +if (x_463 == 0) +{ +lean_object* x_464; uint8_t x_465; +x_464 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_465 = lean_name_eq(x_10, x_464); +if (x_465 == 0) +{ +lean_object* x_466; uint8_t x_467; +x_466 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; +x_467 = lean_name_eq(x_10, x_466); +if (x_467 == 0) +{ +lean_object* x_468; uint8_t x_469; +x_468 = l_Lean_Parser_Term_binop___elambda__1___closed__2; +x_469 = lean_name_eq(x_10, x_468); +if (x_469 == 0) +{ +lean_object* x_470; uint8_t x_471; +x_470 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_471 = lean_name_eq(x_10, x_470); +if (x_471 == 0) +{ +lean_object* x_472; uint8_t x_473; +x_472 = l_Lean_strLitKind; +x_473 = lean_name_eq(x_10, x_472); +if (x_473 == 0) +{ +lean_object* x_474; uint8_t x_475; +x_474 = l_Lean_numLitKind; +x_475 = lean_name_eq(x_10, x_474); +if (x_475 == 0) +{ +lean_object* x_476; uint8_t x_477; +x_476 = l_Lean_scientificLitKind; +x_477 = lean_name_eq(x_10, x_476); +if (x_477 == 0) +{ +lean_object* x_478; uint8_t x_479; +x_478 = l_Lean_charLitKind; +x_479 = lean_name_eq(x_10, x_478); +if (x_479 == 0) +{ +lean_object* x_480; uint8_t x_481; +x_480 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_481 = lean_name_eq(x_10, x_480); +if (x_481 == 0) +{ +lean_object* x_482; uint8_t x_483; +x_482 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; +x_483 = lean_name_eq(x_10, x_482); +if (x_483 == 0) +{ +lean_object* x_484; uint8_t x_485; lean_dec(x_1); +x_484 = l_Lean_choiceKind; +x_485 = lean_name_eq(x_10, x_484); +lean_dec(x_10); +if (x_485 == 0) +{ +lean_object* x_486; +x_486 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_453); +lean_dec(x_2); +return x_486; +} +else +{ +lean_object* x_487; lean_object* x_488; +x_487 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; +x_488 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_487, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_453); +lean_dec(x_2); +return x_488; +} +} +else +{ +lean_object* x_489; +lean_dec(x_10); +lean_dec(x_2); +x_489 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_489; +} +} +else +{ +lean_object* x_490; +lean_dec(x_10); +lean_dec(x_2); +x_490 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_8); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_490; +} +} +else +{ +lean_object* x_491; +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_491 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_491, 0, x_1); +lean_ctor_set(x_491, 1, x_440); +return x_491; +} +} +else +{ +lean_object* x_492; +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_492 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_492, 0, x_1); +lean_ctor_set(x_492, 1, x_440); +return x_492; +} +} +else +{ +lean_object* x_493; +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_493 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_493, 0, x_1); +lean_ctor_set(x_493, 1, x_440); +return x_493; +} +} +else +{ +lean_object* x_494; +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_494 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_494, 0, x_1); +lean_ctor_set(x_494, 1, x_440); +return x_494; +} +} +else +{ +lean_object* x_495; +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_495 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_495, 0, x_1); +lean_ctor_set(x_495, 1, x_440); +return x_495; +} +} +else +{ +lean_object* x_496; lean_object* x_497; lean_object* x_498; +lean_dec(x_10); +x_496 = lean_unsigned_to_nat(2u); +x_497 = l_Lean_Syntax_getArg(x_1, x_496); lean_inc(x_8); lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); lean_inc(x_4); -lean_inc(x_402); -x_449 = l_Lean_Elab_Term_CollectPatternVars_collect(x_448, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_446); -if (lean_obj_tag(x_449) == 0) -{ -lean_object* x_450; lean_object* x_451; lean_object* x_452; lean_object* x_453; lean_object* x_454; lean_object* x_455; lean_object* x_456; lean_object* x_457; lean_object* x_458; lean_object* x_459; lean_object* x_460; lean_object* x_461; lean_object* x_462; lean_object* x_463; lean_object* x_464; lean_object* x_465; lean_object* x_466; lean_object* x_467; lean_object* x_468; lean_object* x_469; lean_object* x_470; lean_object* x_471; lean_object* x_472; lean_object* x_473; lean_object* x_474; lean_object* x_475; -x_450 = lean_ctor_get(x_449, 0); -lean_inc(x_450); -x_451 = lean_ctor_get(x_449, 1); -lean_inc(x_451); -lean_dec(x_449); -x_452 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_451); -x_453 = lean_ctor_get(x_452, 0); lean_inc(x_453); -x_454 = lean_ctor_get(x_452, 1); -lean_inc(x_454); -lean_dec(x_452); -x_455 = l_Lean_Elab_Term_getCurrMacroScope(x_402, x_4, x_5, x_6, x_7, x_8, x_454); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_402); -x_456 = lean_ctor_get(x_455, 0); -lean_inc(x_456); -x_457 = lean_ctor_get(x_455, 1); -lean_inc(x_457); -lean_dec(x_455); -x_458 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_457); -lean_dec(x_8); -x_459 = lean_ctor_get(x_458, 0); -lean_inc(x_459); -x_460 = lean_ctor_get(x_458, 1); -lean_inc(x_460); -if (lean_is_exclusive(x_458)) { - lean_ctor_release(x_458, 0); - lean_ctor_release(x_458, 1); - x_461 = x_458; -} else { - lean_dec_ref(x_458); - x_461 = lean_box(0); -} -x_462 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; -x_463 = l_Lean_addMacroScope(x_459, x_462, x_456); -x_464 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; -x_465 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; -x_466 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_466, 0, x_453); -lean_ctor_set(x_466, 1, x_464); -lean_ctor_set(x_466, 2, x_463); -lean_ctor_set(x_466, 3, x_465); -x_467 = l_Array_empty___closed__1; -x_468 = lean_array_push(x_467, x_466); -x_469 = lean_array_push(x_467, x_444); -x_470 = lean_array_push(x_469, x_450); -x_471 = l_Lean_nullKind___closed__2; -x_472 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_472, 0, x_471); -lean_ctor_set(x_472, 1, x_470); -x_473 = lean_array_push(x_468, x_472); -x_474 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_474, 0, x_403); -lean_ctor_set(x_474, 1, x_473); -if (lean_is_scalar(x_461)) { - x_475 = lean_alloc_ctor(0, 2, 0); -} else { - x_475 = x_461; -} -lean_ctor_set(x_475, 0, x_474); -lean_ctor_set(x_475, 1, x_460); -return x_475; -} -else -{ -lean_object* x_476; lean_object* x_477; lean_object* x_478; lean_object* x_479; -lean_dec(x_444); -lean_dec(x_402); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -x_476 = lean_ctor_get(x_449, 0); -lean_inc(x_476); -x_477 = lean_ctor_get(x_449, 1); -lean_inc(x_477); -if (lean_is_exclusive(x_449)) { - lean_ctor_release(x_449, 0); - lean_ctor_release(x_449, 1); - x_478 = x_449; -} else { - lean_dec_ref(x_449); - x_478 = lean_box(0); -} -if (lean_is_scalar(x_478)) { - x_479 = lean_alloc_ctor(1, 2, 0); -} else { - x_479 = x_478; -} -lean_ctor_set(x_479, 0, x_476); -lean_ctor_set(x_479, 1, x_477); -return x_479; -} -} -else -{ -lean_object* x_480; lean_object* x_481; lean_object* x_482; lean_object* x_483; -lean_dec(x_444); -lean_dec(x_402); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_480 = lean_ctor_get(x_445, 0); -lean_inc(x_480); -x_481 = lean_ctor_get(x_445, 1); -lean_inc(x_481); -if (lean_is_exclusive(x_445)) { - lean_ctor_release(x_445, 0); - lean_ctor_release(x_445, 1); - x_482 = x_445; -} else { - lean_dec_ref(x_445); - x_482 = lean_box(0); -} -if (lean_is_scalar(x_482)) { - x_483 = lean_alloc_ctor(1, 2, 0); -} else { - x_483 = x_482; -} -lean_ctor_set(x_483, 0, x_480); -lean_ctor_set(x_483, 1, x_481); -return x_483; -} -} -} -else -{ -lean_object* x_484; lean_object* x_485; lean_object* x_486; -lean_dec(x_10); -x_484 = lean_unsigned_to_nat(0u); -x_485 = l_Lean_Syntax_getArg(x_1, x_484); -lean_dec(x_1); -x_486 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_485, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -return x_486; -} -} -else -{ -lean_object* x_487; uint8_t x_488; -lean_dec(x_10); -x_487 = l_Lean_Syntax_getArg(x_1, x_22); -x_488 = l_Lean_Syntax_isNone(x_487); -if (x_488 == 0) -{ -lean_object* x_489; lean_object* x_490; lean_object* x_491; uint8_t x_492; -x_489 = lean_unsigned_to_nat(0u); -x_490 = l_Lean_Syntax_getArg(x_487, x_489); -x_491 = l_Lean_Syntax_getArg(x_487, x_22); -x_492 = l_Lean_Syntax_isNone(x_491); -if (x_492 == 0) -{ -lean_object* x_493; lean_object* x_494; lean_object* x_495; uint8_t x_496; -x_493 = l_Lean_Syntax_getArg(x_491, x_489); -lean_dec(x_491); -x_494 = l_Lean_Syntax_getKind(x_493); -x_495 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; -x_496 = lean_name_eq(x_494, x_495); -lean_dec(x_494); -if (x_496 == 0) -{ -lean_object* x_497; -lean_dec(x_490); -lean_dec(x_487); -lean_dec(x_402); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -x_497 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_497, 0, x_1); -lean_ctor_set(x_497, 1, x_389); -return x_497; -} -else -{ -lean_object* x_498; -x_498 = l_Lean_Elab_Term_CollectPatternVars_collect(x_490, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); +lean_inc(x_2); +x_498 = l_Lean_Elab_Term_CollectPatternVars_collect(x_497, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); if (lean_obj_tag(x_498) == 0) { -lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; lean_object* x_504; +lean_object* x_499; lean_object* x_500; lean_object* x_501; lean_object* x_502; lean_object* x_503; x_499 = lean_ctor_get(x_498, 0); lean_inc(x_499); x_500 = lean_ctor_get(x_498, 1); lean_inc(x_500); -if (lean_is_exclusive(x_498)) { - lean_ctor_release(x_498, 0); - lean_ctor_release(x_498, 1); - x_501 = x_498; -} else { - lean_dec_ref(x_498); - x_501 = lean_box(0); -} -x_502 = l_Lean_Syntax_setArg(x_487, x_489, x_499); -x_503 = l_Lean_Syntax_setArg(x_1, x_22, x_502); -if (lean_is_scalar(x_501)) { - x_504 = lean_alloc_ctor(0, 2, 0); -} else { - x_504 = x_501; -} -lean_ctor_set(x_504, 0, x_503); -lean_ctor_set(x_504, 1, x_500); -return x_504; -} -else +lean_dec(x_498); +x_501 = lean_unsigned_to_nat(3u); +x_502 = l_Lean_Syntax_getArg(x_1, x_501); +x_503 = l_Lean_Elab_Term_CollectPatternVars_collect(x_502, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_500); +if (lean_obj_tag(x_503) == 0) { -lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; -lean_dec(x_487); -lean_dec(x_1); -x_505 = lean_ctor_get(x_498, 0); +lean_object* x_504; lean_object* x_505; lean_object* x_506; lean_object* x_507; lean_object* x_508; lean_object* x_509; +x_504 = lean_ctor_get(x_503, 0); +lean_inc(x_504); +x_505 = lean_ctor_get(x_503, 1); lean_inc(x_505); -x_506 = lean_ctor_get(x_498, 1); -lean_inc(x_506); -if (lean_is_exclusive(x_498)) { - lean_ctor_release(x_498, 0); - lean_ctor_release(x_498, 1); - x_507 = x_498; +if (lean_is_exclusive(x_503)) { + lean_ctor_release(x_503, 0); + lean_ctor_release(x_503, 1); + x_506 = x_503; } else { - lean_dec_ref(x_498); - x_507 = lean_box(0); + lean_dec_ref(x_503); + x_506 = lean_box(0); } -if (lean_is_scalar(x_507)) { - x_508 = lean_alloc_ctor(1, 2, 0); +x_507 = l_Lean_Syntax_setArg(x_1, x_496, x_499); +x_508 = l_Lean_Syntax_setArg(x_507, x_501, x_504); +if (lean_is_scalar(x_506)) { + x_509 = lean_alloc_ctor(0, 2, 0); } else { - x_508 = x_507; -} -lean_ctor_set(x_508, 0, x_505); -lean_ctor_set(x_508, 1, x_506); -return x_508; -} + x_509 = x_506; } +lean_ctor_set(x_509, 0, x_508); +lean_ctor_set(x_509, 1, x_505); +return x_509; } else { -lean_object* x_509; -lean_dec(x_491); -x_509 = l_Lean_Elab_Term_CollectPatternVars_collect(x_490, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -if (lean_obj_tag(x_509) == 0) -{ -lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; lean_object* x_514; lean_object* x_515; -x_510 = lean_ctor_get(x_509, 0); +lean_object* x_510; lean_object* x_511; lean_object* x_512; lean_object* x_513; +lean_dec(x_499); +lean_dec(x_1); +x_510 = lean_ctor_get(x_503, 0); lean_inc(x_510); -x_511 = lean_ctor_get(x_509, 1); +x_511 = lean_ctor_get(x_503, 1); lean_inc(x_511); -if (lean_is_exclusive(x_509)) { - lean_ctor_release(x_509, 0); - lean_ctor_release(x_509, 1); - x_512 = x_509; +if (lean_is_exclusive(x_503)) { + lean_ctor_release(x_503, 0); + lean_ctor_release(x_503, 1); + x_512 = x_503; } else { - lean_dec_ref(x_509); + lean_dec_ref(x_503); x_512 = lean_box(0); } -x_513 = l_Lean_Syntax_setArg(x_487, x_489, x_510); -x_514 = l_Lean_Syntax_setArg(x_1, x_22, x_513); if (lean_is_scalar(x_512)) { - x_515 = lean_alloc_ctor(0, 2, 0); + x_513 = lean_alloc_ctor(1, 2, 0); } else { - x_515 = x_512; -} -lean_ctor_set(x_515, 0, x_514); -lean_ctor_set(x_515, 1, x_511); -return x_515; -} -else -{ -lean_object* x_516; lean_object* x_517; lean_object* x_518; lean_object* x_519; -lean_dec(x_487); -lean_dec(x_1); -x_516 = lean_ctor_get(x_509, 0); -lean_inc(x_516); -x_517 = lean_ctor_get(x_509, 1); -lean_inc(x_517); -if (lean_is_exclusive(x_509)) { - lean_ctor_release(x_509, 0); - lean_ctor_release(x_509, 1); - x_518 = x_509; -} else { - lean_dec_ref(x_509); - x_518 = lean_box(0); -} -if (lean_is_scalar(x_518)) { - x_519 = lean_alloc_ctor(1, 2, 0); -} else { - x_519 = x_518; -} -lean_ctor_set(x_519, 0, x_516); -lean_ctor_set(x_519, 1, x_517); -return x_519; + x_513 = x_512; } +lean_ctor_set(x_513, 0, x_510); +lean_ctor_set(x_513, 1, x_511); +return x_513; } } else { -lean_object* x_520; -lean_dec(x_487); -lean_dec(x_402); +lean_object* x_514; lean_object* x_515; lean_object* x_516; lean_object* x_517; +lean_dec(x_453); lean_dec(x_7); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -x_520 = lean_alloc_ctor(0, 2, 0); -lean_ctor_set(x_520, 0, x_1); -lean_ctor_set(x_520, 1, x_389); -return x_520; +lean_dec(x_1); +x_514 = lean_ctor_get(x_498, 0); +lean_inc(x_514); +x_515 = lean_ctor_get(x_498, 1); +lean_inc(x_515); +if (lean_is_exclusive(x_498)) { + lean_ctor_release(x_498, 0); + lean_ctor_release(x_498, 1); + x_516 = x_498; +} else { + lean_dec_ref(x_498); + x_516 = lean_box(0); +} +if (lean_is_scalar(x_516)) { + x_517 = lean_alloc_ctor(1, 2, 0); +} else { + x_517 = x_516; +} +lean_ctor_set(x_517, 0, x_514); +lean_ctor_set(x_517, 1, x_515); +return x_517; } } } else { -lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; -lean_dec(x_402); -lean_dec(x_7); +lean_object* x_518; lean_object* x_519; lean_object* x_520; lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); +x_518 = lean_unsigned_to_nat(0u); +x_519 = l_Lean_Syntax_getArg(x_1, x_518); +lean_inc(x_7); +lean_inc(x_519); +x_520 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_519, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +if (lean_obj_tag(x_520) == 0) +{ +lean_object* x_521; lean_object* x_522; lean_object* x_523; lean_object* x_524; +x_521 = lean_ctor_get(x_520, 1); +lean_inc(x_521); +lean_dec(x_520); +x_522 = lean_unsigned_to_nat(2u); +x_523 = l_Lean_Syntax_getArg(x_1, x_522); lean_dec(x_1); -x_521 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_389); -x_522 = lean_ctor_get(x_521, 0); -lean_inc(x_522); -x_523 = lean_ctor_get(x_521, 1); -lean_inc(x_523); -lean_dec(x_521); -x_524 = lean_st_ref_get(x_8, x_523); -lean_dec(x_8); -x_525 = lean_ctor_get(x_524, 1); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_453); +x_524 = l_Lean_Elab_Term_CollectPatternVars_collect(x_523, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_521); +if (lean_obj_tag(x_524) == 0) +{ +lean_object* x_525; lean_object* x_526; lean_object* x_527; lean_object* x_528; lean_object* x_529; lean_object* x_530; lean_object* x_531; lean_object* x_532; lean_object* x_533; lean_object* x_534; lean_object* x_535; lean_object* x_536; lean_object* x_537; lean_object* x_538; lean_object* x_539; lean_object* x_540; lean_object* x_541; lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; lean_object* x_548; lean_object* x_549; lean_object* x_550; +x_525 = lean_ctor_get(x_524, 0); lean_inc(x_525); +x_526 = lean_ctor_get(x_524, 1); +lean_inc(x_526); lean_dec(x_524); -x_526 = lean_st_ref_take(x_2, x_525); -x_527 = lean_ctor_get(x_526, 0); -lean_inc(x_527); -x_528 = lean_ctor_get(x_526, 1); +x_527 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_526); +x_528 = lean_ctor_get(x_527, 0); lean_inc(x_528); -lean_dec(x_526); -x_529 = lean_ctor_get(x_527, 0); +x_529 = lean_ctor_get(x_527, 1); lean_inc(x_529); -x_530 = lean_ctor_get(x_527, 1); -lean_inc(x_530); -if (lean_is_exclusive(x_527)) { - lean_ctor_release(x_527, 0); - lean_ctor_release(x_527, 1); - x_531 = x_527; +lean_dec(x_527); +x_530 = l_Lean_Elab_Term_getCurrMacroScope(x_453, x_4, x_5, x_6, x_7, x_8, x_529); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_453); +x_531 = lean_ctor_get(x_530, 0); +lean_inc(x_531); +x_532 = lean_ctor_get(x_530, 1); +lean_inc(x_532); +lean_dec(x_530); +x_533 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_532); +lean_dec(x_8); +x_534 = lean_ctor_get(x_533, 0); +lean_inc(x_534); +x_535 = lean_ctor_get(x_533, 1); +lean_inc(x_535); +if (lean_is_exclusive(x_533)) { + lean_ctor_release(x_533, 0); + lean_ctor_release(x_533, 1); + x_536 = x_533; } else { - lean_dec_ref(x_527); - x_531 = lean_box(0); + lean_dec_ref(x_533); + x_536 = lean_box(0); } -x_532 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_522); -x_533 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_533, 0, x_532); -x_534 = lean_array_push(x_530, x_533); -if (lean_is_scalar(x_531)) { - x_535 = lean_alloc_ctor(0, 2, 0); +x_537 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; +x_538 = l_Lean_addMacroScope(x_534, x_537, x_531); +x_539 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; +x_540 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; +x_541 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_541, 0, x_528); +lean_ctor_set(x_541, 1, x_539); +lean_ctor_set(x_541, 2, x_538); +lean_ctor_set(x_541, 3, x_540); +x_542 = l_Array_empty___closed__1; +x_543 = lean_array_push(x_542, x_541); +x_544 = lean_array_push(x_542, x_519); +x_545 = lean_array_push(x_544, x_525); +x_546 = l_Lean_nullKind___closed__2; +x_547 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_547, 0, x_546); +lean_ctor_set(x_547, 1, x_545); +x_548 = lean_array_push(x_543, x_547); +x_549 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_549, 0, x_454); +lean_ctor_set(x_549, 1, x_548); +if (lean_is_scalar(x_536)) { + x_550 = lean_alloc_ctor(0, 2, 0); } else { - x_535 = x_531; -} -lean_ctor_set(x_535, 0, x_529); -lean_ctor_set(x_535, 1, x_534); -x_536 = lean_st_ref_set(x_2, x_535, x_528); -lean_dec(x_2); -x_537 = lean_ctor_get(x_536, 1); -lean_inc(x_537); -if (lean_is_exclusive(x_536)) { - lean_ctor_release(x_536, 0); - lean_ctor_release(x_536, 1); - x_538 = x_536; -} else { - lean_dec_ref(x_536); - x_538 = lean_box(0); -} -if (lean_is_scalar(x_538)) { - x_539 = lean_alloc_ctor(0, 2, 0); -} else { - x_539 = x_538; -} -lean_ctor_set(x_539, 0, x_522); -lean_ctor_set(x_539, 1, x_537); -return x_539; + x_550 = x_536; } +lean_ctor_set(x_550, 0, x_549); +lean_ctor_set(x_550, 1, x_535); +return x_550; } else { -lean_object* x_540; uint8_t x_541; -lean_dec(x_10); -x_540 = l_Lean_Syntax_getArg(x_1, x_22); -x_541 = l_Lean_Syntax_isNone(x_540); -if (x_541 == 0) -{ -lean_object* x_542; lean_object* x_543; lean_object* x_544; lean_object* x_545; lean_object* x_546; lean_object* x_547; -lean_dec(x_1); -x_542 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; -x_543 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_540, x_542, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); +lean_object* x_551; lean_object* x_552; lean_object* x_553; lean_object* x_554; +lean_dec(x_519); +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_551 = lean_ctor_get(x_524, 0); +lean_inc(x_551); +x_552 = lean_ctor_get(x_524, 1); +lean_inc(x_552); +if (lean_is_exclusive(x_524)) { + lean_ctor_release(x_524, 0); + lean_ctor_release(x_524, 1); + x_553 = x_524; +} else { + lean_dec_ref(x_524); + x_553 = lean_box(0); +} +if (lean_is_scalar(x_553)) { + x_554 = lean_alloc_ctor(1, 2, 0); +} else { + x_554 = x_553; +} +lean_ctor_set(x_554, 0, x_551); +lean_ctor_set(x_554, 1, x_552); +return x_554; +} +} +else +{ +lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; +lean_dec(x_519); +lean_dec(x_453); +lean_dec(x_7); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_402); lean_dec(x_2); -lean_dec(x_540); -x_544 = lean_ctor_get(x_543, 0); -lean_inc(x_544); -x_545 = lean_ctor_get(x_543, 1); -lean_inc(x_545); -if (lean_is_exclusive(x_543)) { - lean_ctor_release(x_543, 0); - lean_ctor_release(x_543, 1); - x_546 = x_543; -} else { - lean_dec_ref(x_543); - x_546 = lean_box(0); -} -if (lean_is_scalar(x_546)) { - x_547 = lean_alloc_ctor(1, 2, 0); -} else { - x_547 = x_546; -} -lean_ctor_set(x_547, 0, x_544); -lean_ctor_set(x_547, 1, x_545); -return x_547; -} -else -{ -lean_object* x_548; lean_object* x_549; -lean_dec(x_540); -x_548 = lean_box(0); -x_549 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_548, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -return x_549; -} -} -} -else -{ -lean_object* x_550; lean_object* x_551; lean_object* x_552; lean_object* x_553; -lean_dec(x_10); -x_550 = l_Lean_Syntax_getArg(x_1, x_22); -x_551 = l_Lean_Syntax_getArgs(x_550); -lean_dec(x_550); -x_552 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; -x_553 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_551, x_552, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -lean_dec(x_551); -if (lean_obj_tag(x_553) == 0) -{ -lean_object* x_554; lean_object* x_555; lean_object* x_556; lean_object* x_557; lean_object* x_558; lean_object* x_559; lean_object* x_560; -x_554 = lean_ctor_get(x_553, 0); -lean_inc(x_554); -x_555 = lean_ctor_get(x_553, 1); +lean_dec(x_1); +x_555 = lean_ctor_get(x_520, 0); lean_inc(x_555); -if (lean_is_exclusive(x_553)) { - lean_ctor_release(x_553, 0); - lean_ctor_release(x_553, 1); - x_556 = x_553; +x_556 = lean_ctor_get(x_520, 1); +lean_inc(x_556); +if (lean_is_exclusive(x_520)) { + lean_ctor_release(x_520, 0); + lean_ctor_release(x_520, 1); + x_557 = x_520; } else { - lean_dec_ref(x_553); - x_556 = lean_box(0); + lean_dec_ref(x_520); + x_557 = lean_box(0); } -x_557 = l_Lean_nullKind; -x_558 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_558, 0, x_557); -lean_ctor_set(x_558, 1, x_554); -x_559 = l_Lean_Syntax_setArg(x_1, x_22, x_558); -if (lean_is_scalar(x_556)) { - x_560 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_557)) { + x_558 = lean_alloc_ctor(1, 2, 0); } else { - x_560 = x_556; + x_558 = x_557; } -lean_ctor_set(x_560, 0, x_559); -lean_ctor_set(x_560, 1, x_555); -return x_560; -} -else -{ -lean_object* x_561; lean_object* x_562; lean_object* x_563; lean_object* x_564; -lean_dec(x_1); -x_561 = lean_ctor_get(x_553, 0); -lean_inc(x_561); -x_562 = lean_ctor_get(x_553, 1); -lean_inc(x_562); -if (lean_is_exclusive(x_553)) { - lean_ctor_release(x_553, 0); - lean_ctor_release(x_553, 1); - x_563 = x_553; -} else { - lean_dec_ref(x_553); - x_563 = lean_box(0); -} -if (lean_is_scalar(x_563)) { - x_564 = lean_alloc_ctor(1, 2, 0); -} else { - x_564 = x_563; -} -lean_ctor_set(x_564, 0, x_561); -lean_ctor_set(x_564, 1, x_562); -return x_564; +lean_ctor_set(x_558, 0, x_555); +lean_ctor_set(x_558, 1, x_556); +return x_558; } } } else { -lean_object* x_565; +lean_object* x_559; lean_object* x_560; lean_object* x_561; lean_dec(x_10); -x_565 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); +x_559 = lean_unsigned_to_nat(0u); +x_560 = l_Lean_Syntax_getArg(x_1, x_559); lean_dec(x_1); -return x_565; +x_561 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_560, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +return x_561; } } else { -lean_object* x_566; +lean_object* x_562; uint8_t x_563; lean_dec(x_10); -x_566 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_402, x_4, x_5, x_6, x_7, x_8, x_389); -return x_566; -} -} +x_562 = l_Lean_Syntax_getArg(x_1, x_22); +x_563 = l_Lean_Syntax_isNone(x_562); +if (x_563 == 0) +{ +lean_object* x_564; lean_object* x_565; lean_object* x_566; uint8_t x_567; +x_564 = lean_unsigned_to_nat(0u); +x_565 = l_Lean_Syntax_getArg(x_562, x_564); +x_566 = l_Lean_Syntax_getArg(x_562, x_22); +x_567 = l_Lean_Syntax_isNone(x_566); +if (x_567 == 0) +{ +lean_object* x_568; lean_object* x_569; lean_object* x_570; uint8_t x_571; +x_568 = l_Lean_Syntax_getArg(x_566, x_564); +lean_dec(x_566); +x_569 = l_Lean_Syntax_getKind(x_568); +x_570 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; +x_571 = lean_name_eq(x_569, x_570); +lean_dec(x_569); +if (x_571 == 0) +{ +lean_object* x_572; +lean_dec(x_565); +lean_dec(x_562); +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +x_572 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_572, 0, x_1); +lean_ctor_set(x_572, 1, x_440); +return x_572; } else { -lean_object* x_567; lean_object* x_568; lean_object* x_569; lean_object* x_570; lean_object* x_571; lean_object* x_572; lean_object* x_573; lean_object* x_574; lean_object* x_575; lean_object* x_576; lean_object* x_577; lean_object* x_578; lean_object* x_579; lean_object* x_580; uint8_t x_581; uint8_t x_582; uint8_t x_583; lean_object* x_584; lean_object* x_585; lean_object* x_586; uint8_t x_587; lean_object* x_588; lean_object* x_589; -x_567 = lean_ctor_get(x_18, 0); -x_568 = lean_ctor_get(x_18, 1); -x_569 = lean_ctor_get(x_18, 2); -x_570 = lean_ctor_get(x_18, 3); -lean_inc(x_570); -lean_inc(x_569); -lean_inc(x_568); -lean_inc(x_567); -lean_dec(x_18); -x_571 = lean_unsigned_to_nat(1u); -x_572 = lean_nat_add(x_568, x_571); -x_573 = lean_alloc_ctor(0, 4, 0); -lean_ctor_set(x_573, 0, x_567); -lean_ctor_set(x_573, 1, x_572); -lean_ctor_set(x_573, 2, x_569); -lean_ctor_set(x_573, 3, x_570); -x_574 = lean_st_ref_set(x_8, x_573, x_19); -x_575 = lean_ctor_get(x_574, 1); +lean_object* x_573; +x_573 = l_Lean_Elab_Term_CollectPatternVars_collect(x_565, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +if (lean_obj_tag(x_573) == 0) +{ +lean_object* x_574; lean_object* x_575; lean_object* x_576; lean_object* x_577; lean_object* x_578; lean_object* x_579; +x_574 = lean_ctor_get(x_573, 0); +lean_inc(x_574); +x_575 = lean_ctor_get(x_573, 1); lean_inc(x_575); -if (lean_is_exclusive(x_574)) { - lean_ctor_release(x_574, 0); - lean_ctor_release(x_574, 1); - x_576 = x_574; +if (lean_is_exclusive(x_573)) { + lean_ctor_release(x_573, 0); + lean_ctor_release(x_573, 1); + x_576 = x_573; } else { - lean_dec_ref(x_574); + lean_dec_ref(x_573); x_576 = lean_box(0); } -x_577 = lean_ctor_get(x_3, 0); -lean_inc(x_577); -x_578 = lean_ctor_get(x_3, 1); -lean_inc(x_578); -x_579 = lean_ctor_get(x_3, 2); -lean_inc(x_579); -x_580 = lean_ctor_get(x_3, 3); -lean_inc(x_580); -x_581 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); -x_582 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); -x_583 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); -x_584 = lean_ctor_get(x_3, 5); -lean_inc(x_584); -x_585 = lean_ctor_get(x_3, 6); -lean_inc(x_585); -x_586 = lean_ctor_get(x_3, 7); -lean_inc(x_586); -x_587 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); -if (lean_is_exclusive(x_3)) { - lean_ctor_release(x_3, 0); - lean_ctor_release(x_3, 1); - lean_ctor_release(x_3, 2); - lean_ctor_release(x_3, 3); - lean_ctor_release(x_3, 4); - lean_ctor_release(x_3, 5); - lean_ctor_release(x_3, 6); - lean_ctor_release(x_3, 7); - x_588 = x_3; +x_577 = l_Lean_Syntax_setArg(x_562, x_564, x_574); +x_578 = l_Lean_Syntax_setArg(x_1, x_22, x_577); +if (lean_is_scalar(x_576)) { + x_579 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_3); - x_588 = lean_box(0); + x_579 = x_576; } -if (lean_is_scalar(x_588)) { - x_589 = lean_alloc_ctor(0, 8, 4); -} else { - x_589 = x_588; -} -lean_ctor_set(x_589, 0, x_577); -lean_ctor_set(x_589, 1, x_578); -lean_ctor_set(x_589, 2, x_579); -lean_ctor_set(x_589, 3, x_580); -lean_ctor_set(x_589, 4, x_568); -lean_ctor_set(x_589, 5, x_584); -lean_ctor_set(x_589, 6, x_585); -lean_ctor_set(x_589, 7, x_586); -lean_ctor_set_uint8(x_589, sizeof(void*)*8, x_581); -lean_ctor_set_uint8(x_589, sizeof(void*)*8 + 1, x_582); -lean_ctor_set_uint8(x_589, sizeof(void*)*8 + 2, x_583); -lean_ctor_set_uint8(x_589, sizeof(void*)*8 + 3, x_587); -if (x_17 == 0) -{ -lean_object* x_590; uint8_t x_591; -x_590 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; -x_591 = lean_name_eq(x_10, x_590); -if (x_591 == 0) -{ -lean_object* x_592; uint8_t x_593; -x_592 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_593 = lean_name_eq(x_10, x_592); -if (x_593 == 0) -{ -lean_object* x_594; uint8_t x_595; -x_594 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; -x_595 = lean_name_eq(x_10, x_594); -if (x_595 == 0) -{ -lean_object* x_596; uint8_t x_597; -x_596 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; -x_597 = lean_name_eq(x_10, x_596); -if (x_597 == 0) -{ -lean_object* x_598; uint8_t x_599; -x_598 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; -x_599 = lean_name_eq(x_10, x_598); -if (x_599 == 0) -{ -lean_object* x_600; uint8_t x_601; -x_600 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; -x_601 = lean_name_eq(x_10, x_600); -if (x_601 == 0) -{ -lean_object* x_602; uint8_t x_603; -x_602 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; -x_603 = lean_name_eq(x_10, x_602); -if (x_603 == 0) -{ -lean_object* x_604; uint8_t x_605; -x_604 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_605 = lean_name_eq(x_10, x_604); -if (x_605 == 0) -{ -lean_object* x_606; uint8_t x_607; -x_606 = l_Lean_strLitKind; -x_607 = lean_name_eq(x_10, x_606); -if (x_607 == 0) -{ -lean_object* x_608; uint8_t x_609; -x_608 = l_Lean_numLitKind; -x_609 = lean_name_eq(x_10, x_608); -if (x_609 == 0) -{ -lean_object* x_610; uint8_t x_611; -x_610 = l_Lean_scientificLitKind; -x_611 = lean_name_eq(x_10, x_610); -if (x_611 == 0) -{ -lean_object* x_612; uint8_t x_613; -x_612 = l_Lean_charLitKind; -x_613 = lean_name_eq(x_10, x_612); -if (x_613 == 0) -{ -lean_object* x_614; uint8_t x_615; -lean_dec(x_576); -x_614 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; -x_615 = lean_name_eq(x_10, x_614); -if (x_615 == 0) -{ -lean_object* x_616; uint8_t x_617; -x_616 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; -x_617 = lean_name_eq(x_10, x_616); -if (x_617 == 0) -{ -lean_object* x_618; uint8_t x_619; -lean_dec(x_1); -x_618 = l_Lean_choiceKind; -x_619 = lean_name_eq(x_10, x_618); -lean_dec(x_10); -if (x_619 == 0) -{ -lean_object* x_620; -x_620 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_589); -lean_dec(x_2); -return x_620; +lean_ctor_set(x_579, 0, x_578); +lean_ctor_set(x_579, 1, x_575); +return x_579; } else { -lean_object* x_621; lean_object* x_622; -x_621 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; -x_622 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_621, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_8); +lean_object* x_580; lean_object* x_581; lean_object* x_582; lean_object* x_583; +lean_dec(x_562); +lean_dec(x_1); +x_580 = lean_ctor_get(x_573, 0); +lean_inc(x_580); +x_581 = lean_ctor_get(x_573, 1); +lean_inc(x_581); +if (lean_is_exclusive(x_573)) { + lean_ctor_release(x_573, 0); + lean_ctor_release(x_573, 1); + x_582 = x_573; +} else { + lean_dec_ref(x_573); + x_582 = lean_box(0); +} +if (lean_is_scalar(x_582)) { + x_583 = lean_alloc_ctor(1, 2, 0); +} else { + x_583 = x_582; +} +lean_ctor_set(x_583, 0, x_580); +lean_ctor_set(x_583, 1, x_581); +return x_583; +} +} +} +else +{ +lean_object* x_584; +lean_dec(x_566); +x_584 = l_Lean_Elab_Term_CollectPatternVars_collect(x_565, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +if (lean_obj_tag(x_584) == 0) +{ +lean_object* x_585; lean_object* x_586; lean_object* x_587; lean_object* x_588; lean_object* x_589; lean_object* x_590; +x_585 = lean_ctor_get(x_584, 0); +lean_inc(x_585); +x_586 = lean_ctor_get(x_584, 1); +lean_inc(x_586); +if (lean_is_exclusive(x_584)) { + lean_ctor_release(x_584, 0); + lean_ctor_release(x_584, 1); + x_587 = x_584; +} else { + lean_dec_ref(x_584); + x_587 = lean_box(0); +} +x_588 = l_Lean_Syntax_setArg(x_562, x_564, x_585); +x_589 = l_Lean_Syntax_setArg(x_1, x_22, x_588); +if (lean_is_scalar(x_587)) { + x_590 = lean_alloc_ctor(0, 2, 0); +} else { + x_590 = x_587; +} +lean_ctor_set(x_590, 0, x_589); +lean_ctor_set(x_590, 1, x_586); +return x_590; +} +else +{ +lean_object* x_591; lean_object* x_592; lean_object* x_593; lean_object* x_594; +lean_dec(x_562); +lean_dec(x_1); +x_591 = lean_ctor_get(x_584, 0); +lean_inc(x_591); +x_592 = lean_ctor_get(x_584, 1); +lean_inc(x_592); +if (lean_is_exclusive(x_584)) { + lean_ctor_release(x_584, 0); + lean_ctor_release(x_584, 1); + x_593 = x_584; +} else { + lean_dec_ref(x_584); + x_593 = lean_box(0); +} +if (lean_is_scalar(x_593)) { + x_594 = lean_alloc_ctor(1, 2, 0); +} else { + x_594 = x_593; +} +lean_ctor_set(x_594, 0, x_591); +lean_ctor_set(x_594, 1, x_592); +return x_594; +} +} +} +else +{ +lean_object* x_595; +lean_dec(x_562); +lean_dec(x_453); lean_dec(x_7); +lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_589); lean_dec(x_2); +x_595 = lean_alloc_ctor(0, 2, 0); +lean_ctor_set(x_595, 0, x_1); +lean_ctor_set(x_595, 1, x_440); +return x_595; +} +} +} +else +{ +lean_object* x_596; lean_object* x_597; lean_object* x_598; lean_object* x_599; lean_object* x_600; lean_object* x_601; lean_object* x_602; lean_object* x_603; lean_object* x_604; lean_object* x_605; lean_object* x_606; lean_object* x_607; lean_object* x_608; lean_object* x_609; lean_object* x_610; lean_object* x_611; lean_object* x_612; lean_object* x_613; lean_object* x_614; +lean_dec(x_453); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_596 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_440); +x_597 = lean_ctor_get(x_596, 0); +lean_inc(x_597); +x_598 = lean_ctor_get(x_596, 1); +lean_inc(x_598); +lean_dec(x_596); +x_599 = lean_st_ref_get(x_8, x_598); +lean_dec(x_8); +x_600 = lean_ctor_get(x_599, 1); +lean_inc(x_600); +lean_dec(x_599); +x_601 = lean_st_ref_take(x_2, x_600); +x_602 = lean_ctor_get(x_601, 0); +lean_inc(x_602); +x_603 = lean_ctor_get(x_601, 1); +lean_inc(x_603); +lean_dec(x_601); +x_604 = lean_ctor_get(x_602, 0); +lean_inc(x_604); +x_605 = lean_ctor_get(x_602, 1); +lean_inc(x_605); +if (lean_is_exclusive(x_602)) { + lean_ctor_release(x_602, 0); + lean_ctor_release(x_602, 1); + x_606 = x_602; +} else { + lean_dec_ref(x_602); + x_606 = lean_box(0); +} +x_607 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_597); +x_608 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_608, 0, x_607); +x_609 = lean_array_push(x_605, x_608); +if (lean_is_scalar(x_606)) { + x_610 = lean_alloc_ctor(0, 2, 0); +} else { + x_610 = x_606; +} +lean_ctor_set(x_610, 0, x_604); +lean_ctor_set(x_610, 1, x_609); +x_611 = lean_st_ref_set(x_2, x_610, x_603); +lean_dec(x_2); +x_612 = lean_ctor_get(x_611, 1); +lean_inc(x_612); +if (lean_is_exclusive(x_611)) { + lean_ctor_release(x_611, 0); + lean_ctor_release(x_611, 1); + x_613 = x_611; +} else { + lean_dec_ref(x_611); + x_613 = lean_box(0); +} +if (lean_is_scalar(x_613)) { + x_614 = lean_alloc_ctor(0, 2, 0); +} else { + x_614 = x_613; +} +lean_ctor_set(x_614, 0, x_597); +lean_ctor_set(x_614, 1, x_612); +return x_614; +} +} +else +{ +lean_object* x_615; uint8_t x_616; +lean_dec(x_10); +x_615 = l_Lean_Syntax_getArg(x_1, x_22); +x_616 = l_Lean_Syntax_isNone(x_615); +if (x_616 == 0) +{ +lean_object* x_617; lean_object* x_618; lean_object* x_619; lean_object* x_620; lean_object* x_621; lean_object* x_622; +lean_dec(x_1); +x_617 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; +x_618 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_615, x_617, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_453); +lean_dec(x_2); +lean_dec(x_615); +x_619 = lean_ctor_get(x_618, 0); +lean_inc(x_619); +x_620 = lean_ctor_get(x_618, 1); +lean_inc(x_620); +if (lean_is_exclusive(x_618)) { + lean_ctor_release(x_618, 0); + lean_ctor_release(x_618, 1); + x_621 = x_618; +} else { + lean_dec_ref(x_618); + x_621 = lean_box(0); +} +if (lean_is_scalar(x_621)) { + x_622 = lean_alloc_ctor(1, 2, 0); +} else { + x_622 = x_621; +} +lean_ctor_set(x_622, 0, x_619); +lean_ctor_set(x_622, 1, x_620); return x_622; } -} else { -lean_object* x_623; -lean_dec(x_10); -lean_dec(x_2); -x_623 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -return x_623; -} -} -else -{ -lean_object* x_624; -lean_dec(x_10); -lean_dec(x_2); -x_624 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_8); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); +lean_object* x_623; lean_object* x_624; +lean_dec(x_615); +x_623 = lean_box(0); +x_624 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_623, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); return x_624; } } +} else { -lean_object* x_625; -lean_dec(x_589); -lean_dec(x_7); +lean_object* x_625; lean_object* x_626; lean_object* x_627; lean_object* x_628; lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_625 = lean_alloc_ctor(0, 2, 0); +x_625 = l_Lean_Syntax_getArg(x_1, x_22); +x_626 = l_Lean_Syntax_getArgs(x_625); +lean_dec(x_625); +x_627 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; +x_628 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_626, x_627, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_626); +if (lean_obj_tag(x_628) == 0) +{ +lean_object* x_629; lean_object* x_630; lean_object* x_631; lean_object* x_632; lean_object* x_633; lean_object* x_634; lean_object* x_635; +x_629 = lean_ctor_get(x_628, 0); +lean_inc(x_629); +x_630 = lean_ctor_get(x_628, 1); +lean_inc(x_630); +if (lean_is_exclusive(x_628)) { + lean_ctor_release(x_628, 0); + lean_ctor_release(x_628, 1); + x_631 = x_628; } else { - x_625 = x_576; + lean_dec_ref(x_628); + x_631 = lean_box(0); } -lean_ctor_set(x_625, 0, x_1); -lean_ctor_set(x_625, 1, x_575); -return x_625; -} -} -else -{ -lean_object* x_626; -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_626 = lean_alloc_ctor(0, 2, 0); +x_632 = l_Lean_nullKind; +x_633 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_633, 0, x_632); +lean_ctor_set(x_633, 1, x_629); +x_634 = l_Lean_Syntax_setArg(x_1, x_22, x_633); +if (lean_is_scalar(x_631)) { + x_635 = lean_alloc_ctor(0, 2, 0); } else { - x_626 = x_576; -} -lean_ctor_set(x_626, 0, x_1); -lean_ctor_set(x_626, 1, x_575); -return x_626; + x_635 = x_631; } +lean_ctor_set(x_635, 0, x_634); +lean_ctor_set(x_635, 1, x_630); +return x_635; } else { -lean_object* x_627; -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_627 = lean_alloc_ctor(0, 2, 0); -} else { - x_627 = x_576; -} -lean_ctor_set(x_627, 0, x_1); -lean_ctor_set(x_627, 1, x_575); -return x_627; -} -} -else -{ -lean_object* x_628; -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_628 = lean_alloc_ctor(0, 2, 0); -} else { - x_628 = x_576; -} -lean_ctor_set(x_628, 0, x_1); -lean_ctor_set(x_628, 1, x_575); -return x_628; -} -} -else -{ -lean_object* x_629; -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_629 = lean_alloc_ctor(0, 2, 0); -} else { - x_629 = x_576; -} -lean_ctor_set(x_629, 0, x_1); -lean_ctor_set(x_629, 1, x_575); -return x_629; -} -} -else -{ -lean_object* x_630; lean_object* x_631; lean_object* x_632; -lean_dec(x_576); -lean_dec(x_10); -x_630 = lean_unsigned_to_nat(0u); -x_631 = l_Lean_Syntax_getArg(x_1, x_630); -lean_inc(x_7); -lean_inc(x_631); -x_632 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_631, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -if (lean_obj_tag(x_632) == 0) -{ -lean_object* x_633; lean_object* x_634; lean_object* x_635; lean_object* x_636; -x_633 = lean_ctor_get(x_632, 1); -lean_inc(x_633); -lean_dec(x_632); -x_634 = lean_unsigned_to_nat(2u); -x_635 = l_Lean_Syntax_getArg(x_1, x_634); +lean_object* x_636; lean_object* x_637; lean_object* x_638; lean_object* x_639; lean_dec(x_1); -lean_inc(x_8); -lean_inc(x_7); -lean_inc(x_6); -lean_inc(x_5); -lean_inc(x_4); -lean_inc(x_589); -x_636 = l_Lean_Elab_Term_CollectPatternVars_collect(x_635, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_633); -if (lean_obj_tag(x_636) == 0) -{ -lean_object* x_637; lean_object* x_638; lean_object* x_639; lean_object* x_640; lean_object* x_641; lean_object* x_642; lean_object* x_643; lean_object* x_644; lean_object* x_645; lean_object* x_646; lean_object* x_647; lean_object* x_648; lean_object* x_649; lean_object* x_650; lean_object* x_651; lean_object* x_652; lean_object* x_653; lean_object* x_654; lean_object* x_655; lean_object* x_656; lean_object* x_657; lean_object* x_658; lean_object* x_659; lean_object* x_660; lean_object* x_661; lean_object* x_662; -x_637 = lean_ctor_get(x_636, 0); +x_636 = lean_ctor_get(x_628, 0); +lean_inc(x_636); +x_637 = lean_ctor_get(x_628, 1); lean_inc(x_637); -x_638 = lean_ctor_get(x_636, 1); -lean_inc(x_638); -lean_dec(x_636); -x_639 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_638); -x_640 = lean_ctor_get(x_639, 0); -lean_inc(x_640); -x_641 = lean_ctor_get(x_639, 1); -lean_inc(x_641); -lean_dec(x_639); -x_642 = l_Lean_Elab_Term_getCurrMacroScope(x_589, x_4, x_5, x_6, x_7, x_8, x_641); -lean_dec(x_7); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_589); -x_643 = lean_ctor_get(x_642, 0); -lean_inc(x_643); -x_644 = lean_ctor_get(x_642, 1); +if (lean_is_exclusive(x_628)) { + lean_ctor_release(x_628, 0); + lean_ctor_release(x_628, 1); + x_638 = x_628; +} else { + lean_dec_ref(x_628); + x_638 = lean_box(0); +} +if (lean_is_scalar(x_638)) { + x_639 = lean_alloc_ctor(1, 2, 0); +} else { + x_639 = x_638; +} +lean_ctor_set(x_639, 0, x_636); +lean_ctor_set(x_639, 1, x_637); +return x_639; +} +} +} +else +{ +lean_object* x_640; +lean_dec(x_10); +x_640 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +lean_dec(x_1); +return x_640; +} +} +else +{ +lean_object* x_641; +lean_dec(x_10); +x_641 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_453, x_4, x_5, x_6, x_7, x_8, x_440); +return x_641; +} +} +} +else +{ +lean_object* x_642; lean_object* x_643; lean_object* x_644; lean_object* x_645; lean_object* x_646; lean_object* x_647; lean_object* x_648; lean_object* x_649; lean_object* x_650; lean_object* x_651; lean_object* x_652; lean_object* x_653; lean_object* x_654; lean_object* x_655; uint8_t x_656; uint8_t x_657; uint8_t x_658; lean_object* x_659; lean_object* x_660; lean_object* x_661; uint8_t x_662; lean_object* x_663; lean_object* x_664; +x_642 = lean_ctor_get(x_18, 0); +x_643 = lean_ctor_get(x_18, 1); +x_644 = lean_ctor_get(x_18, 2); +x_645 = lean_ctor_get(x_18, 3); +lean_inc(x_645); lean_inc(x_644); -lean_dec(x_642); -x_645 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_644); -lean_dec(x_8); -x_646 = lean_ctor_get(x_645, 0); -lean_inc(x_646); -x_647 = lean_ctor_get(x_645, 1); -lean_inc(x_647); -if (lean_is_exclusive(x_645)) { - lean_ctor_release(x_645, 0); - lean_ctor_release(x_645, 1); - x_648 = x_645; +lean_inc(x_643); +lean_inc(x_642); +lean_dec(x_18); +x_646 = lean_unsigned_to_nat(1u); +x_647 = lean_nat_add(x_643, x_646); +x_648 = lean_alloc_ctor(0, 4, 0); +lean_ctor_set(x_648, 0, x_642); +lean_ctor_set(x_648, 1, x_647); +lean_ctor_set(x_648, 2, x_644); +lean_ctor_set(x_648, 3, x_645); +x_649 = lean_st_ref_set(x_8, x_648, x_19); +x_650 = lean_ctor_get(x_649, 1); +lean_inc(x_650); +if (lean_is_exclusive(x_649)) { + lean_ctor_release(x_649, 0); + lean_ctor_release(x_649, 1); + x_651 = x_649; } else { - lean_dec_ref(x_645); - x_648 = lean_box(0); -} -x_649 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; -x_650 = l_Lean_addMacroScope(x_646, x_649, x_643); -x_651 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; -x_652 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; -x_653 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_653, 0, x_640); -lean_ctor_set(x_653, 1, x_651); -lean_ctor_set(x_653, 2, x_650); -lean_ctor_set(x_653, 3, x_652); -x_654 = l_Array_empty___closed__1; -x_655 = lean_array_push(x_654, x_653); -x_656 = lean_array_push(x_654, x_631); -x_657 = lean_array_push(x_656, x_637); -x_658 = l_Lean_nullKind___closed__2; -x_659 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_659, 0, x_658); -lean_ctor_set(x_659, 1, x_657); -x_660 = lean_array_push(x_655, x_659); -x_661 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_661, 0, x_590); -lean_ctor_set(x_661, 1, x_660); -if (lean_is_scalar(x_648)) { - x_662 = lean_alloc_ctor(0, 2, 0); -} else { - x_662 = x_648; -} -lean_ctor_set(x_662, 0, x_661); -lean_ctor_set(x_662, 1, x_647); -return x_662; -} -else -{ -lean_object* x_663; lean_object* x_664; lean_object* x_665; lean_object* x_666; -lean_dec(x_631); -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -x_663 = lean_ctor_get(x_636, 0); -lean_inc(x_663); -x_664 = lean_ctor_get(x_636, 1); -lean_inc(x_664); -if (lean_is_exclusive(x_636)) { - lean_ctor_release(x_636, 0); - lean_ctor_release(x_636, 1); - x_665 = x_636; -} else { - lean_dec_ref(x_636); - x_665 = lean_box(0); -} -if (lean_is_scalar(x_665)) { - x_666 = lean_alloc_ctor(1, 2, 0); -} else { - x_666 = x_665; -} -lean_ctor_set(x_666, 0, x_663); -lean_ctor_set(x_666, 1, x_664); -return x_666; -} -} -else -{ -lean_object* x_667; lean_object* x_668; lean_object* x_669; lean_object* x_670; -lean_dec(x_631); -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -lean_dec(x_1); -x_667 = lean_ctor_get(x_632, 0); -lean_inc(x_667); -x_668 = lean_ctor_get(x_632, 1); -lean_inc(x_668); -if (lean_is_exclusive(x_632)) { - lean_ctor_release(x_632, 0); - lean_ctor_release(x_632, 1); - x_669 = x_632; -} else { - lean_dec_ref(x_632); - x_669 = lean_box(0); -} -if (lean_is_scalar(x_669)) { - x_670 = lean_alloc_ctor(1, 2, 0); -} else { - x_670 = x_669; -} -lean_ctor_set(x_670, 0, x_667); -lean_ctor_set(x_670, 1, x_668); -return x_670; -} -} -} -else -{ -lean_object* x_671; lean_object* x_672; lean_object* x_673; -lean_dec(x_576); -lean_dec(x_10); -x_671 = lean_unsigned_to_nat(0u); -x_672 = l_Lean_Syntax_getArg(x_1, x_671); -lean_dec(x_1); -x_673 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_672, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -return x_673; -} -} -else -{ -lean_object* x_674; uint8_t x_675; -lean_dec(x_10); -x_674 = l_Lean_Syntax_getArg(x_1, x_571); -x_675 = l_Lean_Syntax_isNone(x_674); -if (x_675 == 0) -{ -lean_object* x_676; lean_object* x_677; lean_object* x_678; uint8_t x_679; -x_676 = lean_unsigned_to_nat(0u); -x_677 = l_Lean_Syntax_getArg(x_674, x_676); -x_678 = l_Lean_Syntax_getArg(x_674, x_571); -x_679 = l_Lean_Syntax_isNone(x_678); -if (x_679 == 0) -{ -lean_object* x_680; lean_object* x_681; lean_object* x_682; uint8_t x_683; -x_680 = l_Lean_Syntax_getArg(x_678, x_676); -lean_dec(x_678); -x_681 = l_Lean_Syntax_getKind(x_680); -x_682 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; -x_683 = lean_name_eq(x_681, x_682); -lean_dec(x_681); -if (x_683 == 0) -{ -lean_object* x_684; -lean_dec(x_677); -lean_dec(x_674); -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_684 = lean_alloc_ctor(0, 2, 0); -} else { - x_684 = x_576; -} -lean_ctor_set(x_684, 0, x_1); -lean_ctor_set(x_684, 1, x_575); -return x_684; -} -else -{ -lean_object* x_685; -lean_dec(x_576); -x_685 = l_Lean_Elab_Term_CollectPatternVars_collect(x_677, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -if (lean_obj_tag(x_685) == 0) -{ -lean_object* x_686; lean_object* x_687; lean_object* x_688; lean_object* x_689; lean_object* x_690; lean_object* x_691; -x_686 = lean_ctor_get(x_685, 0); -lean_inc(x_686); -x_687 = lean_ctor_get(x_685, 1); -lean_inc(x_687); -if (lean_is_exclusive(x_685)) { - lean_ctor_release(x_685, 0); - lean_ctor_release(x_685, 1); - x_688 = x_685; -} else { - lean_dec_ref(x_685); - x_688 = lean_box(0); -} -x_689 = l_Lean_Syntax_setArg(x_674, x_676, x_686); -x_690 = l_Lean_Syntax_setArg(x_1, x_571, x_689); -if (lean_is_scalar(x_688)) { - x_691 = lean_alloc_ctor(0, 2, 0); -} else { - x_691 = x_688; -} -lean_ctor_set(x_691, 0, x_690); -lean_ctor_set(x_691, 1, x_687); -return x_691; -} -else -{ -lean_object* x_692; lean_object* x_693; lean_object* x_694; lean_object* x_695; -lean_dec(x_674); -lean_dec(x_1); -x_692 = lean_ctor_get(x_685, 0); -lean_inc(x_692); -x_693 = lean_ctor_get(x_685, 1); -lean_inc(x_693); -if (lean_is_exclusive(x_685)) { - lean_ctor_release(x_685, 0); - lean_ctor_release(x_685, 1); - x_694 = x_685; -} else { - lean_dec_ref(x_685); - x_694 = lean_box(0); -} -if (lean_is_scalar(x_694)) { - x_695 = lean_alloc_ctor(1, 2, 0); -} else { - x_695 = x_694; -} -lean_ctor_set(x_695, 0, x_692); -lean_ctor_set(x_695, 1, x_693); -return x_695; -} -} -} -else -{ -lean_object* x_696; -lean_dec(x_678); -lean_dec(x_576); -x_696 = l_Lean_Elab_Term_CollectPatternVars_collect(x_677, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -if (lean_obj_tag(x_696) == 0) -{ -lean_object* x_697; lean_object* x_698; lean_object* x_699; lean_object* x_700; lean_object* x_701; lean_object* x_702; -x_697 = lean_ctor_get(x_696, 0); -lean_inc(x_697); -x_698 = lean_ctor_get(x_696, 1); -lean_inc(x_698); -if (lean_is_exclusive(x_696)) { - lean_ctor_release(x_696, 0); - lean_ctor_release(x_696, 1); - x_699 = x_696; -} else { - lean_dec_ref(x_696); - x_699 = lean_box(0); -} -x_700 = l_Lean_Syntax_setArg(x_674, x_676, x_697); -x_701 = l_Lean_Syntax_setArg(x_1, x_571, x_700); -if (lean_is_scalar(x_699)) { - x_702 = lean_alloc_ctor(0, 2, 0); -} else { - x_702 = x_699; -} -lean_ctor_set(x_702, 0, x_701); -lean_ctor_set(x_702, 1, x_698); -return x_702; -} -else -{ -lean_object* x_703; lean_object* x_704; lean_object* x_705; lean_object* x_706; -lean_dec(x_674); -lean_dec(x_1); -x_703 = lean_ctor_get(x_696, 0); -lean_inc(x_703); -x_704 = lean_ctor_get(x_696, 1); -lean_inc(x_704); -if (lean_is_exclusive(x_696)) { - lean_ctor_release(x_696, 0); - lean_ctor_release(x_696, 1); - x_705 = x_696; -} else { - lean_dec_ref(x_696); - x_705 = lean_box(0); -} -if (lean_is_scalar(x_705)) { - x_706 = lean_alloc_ctor(1, 2, 0); -} else { - x_706 = x_705; -} -lean_ctor_set(x_706, 0, x_703); -lean_ctor_set(x_706, 1, x_704); -return x_706; -} -} -} -else -{ -lean_object* x_707; -lean_dec(x_674); -lean_dec(x_589); -lean_dec(x_7); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_576)) { - x_707 = lean_alloc_ctor(0, 2, 0); -} else { - x_707 = x_576; -} -lean_ctor_set(x_707, 0, x_1); -lean_ctor_set(x_707, 1, x_575); -return x_707; -} -} -} -else -{ -lean_object* x_708; lean_object* x_709; lean_object* x_710; lean_object* x_711; lean_object* x_712; lean_object* x_713; lean_object* x_714; lean_object* x_715; lean_object* x_716; lean_object* x_717; lean_object* x_718; lean_object* x_719; lean_object* x_720; lean_object* x_721; lean_object* x_722; lean_object* x_723; lean_object* x_724; lean_object* x_725; lean_object* x_726; -lean_dec(x_589); -lean_dec(x_576); -lean_dec(x_7); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -x_708 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_575); -x_709 = lean_ctor_get(x_708, 0); -lean_inc(x_709); -x_710 = lean_ctor_get(x_708, 1); -lean_inc(x_710); -lean_dec(x_708); -x_711 = lean_st_ref_get(x_8, x_710); -lean_dec(x_8); -x_712 = lean_ctor_get(x_711, 1); -lean_inc(x_712); -lean_dec(x_711); -x_713 = lean_st_ref_take(x_2, x_712); -x_714 = lean_ctor_get(x_713, 0); -lean_inc(x_714); -x_715 = lean_ctor_get(x_713, 1); -lean_inc(x_715); -lean_dec(x_713); -x_716 = lean_ctor_get(x_714, 0); -lean_inc(x_716); -x_717 = lean_ctor_get(x_714, 1); -lean_inc(x_717); -if (lean_is_exclusive(x_714)) { - lean_ctor_release(x_714, 0); - lean_ctor_release(x_714, 1); - x_718 = x_714; -} else { - lean_dec_ref(x_714); - x_718 = lean_box(0); -} -x_719 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_709); -x_720 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_720, 0, x_719); -x_721 = lean_array_push(x_717, x_720); -if (lean_is_scalar(x_718)) { - x_722 = lean_alloc_ctor(0, 2, 0); -} else { - x_722 = x_718; -} -lean_ctor_set(x_722, 0, x_716); -lean_ctor_set(x_722, 1, x_721); -x_723 = lean_st_ref_set(x_2, x_722, x_715); -lean_dec(x_2); -x_724 = lean_ctor_get(x_723, 1); -lean_inc(x_724); -if (lean_is_exclusive(x_723)) { - lean_ctor_release(x_723, 0); - lean_ctor_release(x_723, 1); - x_725 = x_723; -} else { - lean_dec_ref(x_723); - x_725 = lean_box(0); -} -if (lean_is_scalar(x_725)) { - x_726 = lean_alloc_ctor(0, 2, 0); -} else { - x_726 = x_725; -} -lean_ctor_set(x_726, 0, x_709); -lean_ctor_set(x_726, 1, x_724); -return x_726; -} -} -else -{ -lean_object* x_727; uint8_t x_728; -lean_dec(x_576); -lean_dec(x_10); -x_727 = l_Lean_Syntax_getArg(x_1, x_571); -x_728 = l_Lean_Syntax_isNone(x_727); -if (x_728 == 0) -{ -lean_object* x_729; lean_object* x_730; lean_object* x_731; lean_object* x_732; lean_object* x_733; lean_object* x_734; -lean_dec(x_1); -x_729 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; -x_730 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_727, x_729, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_589); -lean_dec(x_2); -lean_dec(x_727); -x_731 = lean_ctor_get(x_730, 0); -lean_inc(x_731); -x_732 = lean_ctor_get(x_730, 1); -lean_inc(x_732); -if (lean_is_exclusive(x_730)) { - lean_ctor_release(x_730, 0); - lean_ctor_release(x_730, 1); - x_733 = x_730; -} else { - lean_dec_ref(x_730); - x_733 = lean_box(0); -} -if (lean_is_scalar(x_733)) { - x_734 = lean_alloc_ctor(1, 2, 0); -} else { - x_734 = x_733; -} -lean_ctor_set(x_734, 0, x_731); -lean_ctor_set(x_734, 1, x_732); -return x_734; -} -else -{ -lean_object* x_735; lean_object* x_736; -lean_dec(x_727); -x_735 = lean_box(0); -x_736 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_735, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -return x_736; -} -} -} -else -{ -lean_object* x_737; lean_object* x_738; lean_object* x_739; lean_object* x_740; -lean_dec(x_576); -lean_dec(x_10); -x_737 = l_Lean_Syntax_getArg(x_1, x_571); -x_738 = l_Lean_Syntax_getArgs(x_737); -lean_dec(x_737); -x_739 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; -x_740 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_738, x_739, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_738); -if (lean_obj_tag(x_740) == 0) -{ -lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_object* x_744; lean_object* x_745; lean_object* x_746; lean_object* x_747; -x_741 = lean_ctor_get(x_740, 0); -lean_inc(x_741); -x_742 = lean_ctor_get(x_740, 1); -lean_inc(x_742); -if (lean_is_exclusive(x_740)) { - lean_ctor_release(x_740, 0); - lean_ctor_release(x_740, 1); - x_743 = x_740; -} else { - lean_dec_ref(x_740); - x_743 = lean_box(0); -} -x_744 = l_Lean_nullKind; -x_745 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_745, 0, x_744); -lean_ctor_set(x_745, 1, x_741); -x_746 = l_Lean_Syntax_setArg(x_1, x_571, x_745); -if (lean_is_scalar(x_743)) { - x_747 = lean_alloc_ctor(0, 2, 0); -} else { - x_747 = x_743; -} -lean_ctor_set(x_747, 0, x_746); -lean_ctor_set(x_747, 1, x_742); -return x_747; -} -else -{ -lean_object* x_748; lean_object* x_749; lean_object* x_750; lean_object* x_751; -lean_dec(x_1); -x_748 = lean_ctor_get(x_740, 0); -lean_inc(x_748); -x_749 = lean_ctor_get(x_740, 1); -lean_inc(x_749); -if (lean_is_exclusive(x_740)) { - lean_ctor_release(x_740, 0); - lean_ctor_release(x_740, 1); - x_750 = x_740; -} else { - lean_dec_ref(x_740); - x_750 = lean_box(0); -} -if (lean_is_scalar(x_750)) { - x_751 = lean_alloc_ctor(1, 2, 0); -} else { - x_751 = x_750; -} -lean_ctor_set(x_751, 0, x_748); -lean_ctor_set(x_751, 1, x_749); -return x_751; -} -} -} -else -{ -lean_object* x_752; -lean_dec(x_576); -lean_dec(x_10); -x_752 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -lean_dec(x_1); -return x_752; -} -} -else -{ -lean_object* x_753; -lean_dec(x_576); -lean_dec(x_10); -x_753 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_589, x_4, x_5, x_6, x_7, x_8, x_575); -return x_753; -} -} -} -} -else -{ -lean_object* x_761; lean_object* x_762; lean_object* x_763; lean_object* x_764; lean_object* x_765; lean_object* x_766; lean_object* x_767; lean_object* x_768; lean_object* x_769; lean_object* x_770; lean_object* x_771; uint8_t x_772; lean_object* x_773; lean_object* x_774; -x_761 = lean_ctor_get(x_7, 0); -x_762 = lean_ctor_get(x_7, 1); -x_763 = lean_ctor_get(x_7, 2); -x_764 = lean_ctor_get(x_7, 3); -x_765 = lean_ctor_get(x_7, 4); -x_766 = lean_ctor_get(x_7, 5); -x_767 = lean_ctor_get(x_7, 6); -x_768 = lean_ctor_get(x_7, 7); -lean_inc(x_768); -lean_inc(x_767); -lean_inc(x_766); -lean_inc(x_765); -lean_inc(x_764); -lean_inc(x_763); -lean_inc(x_762); -lean_inc(x_761); -lean_dec(x_7); -x_769 = l_Lean_replaceRef(x_1, x_764); -lean_dec(x_764); -x_770 = lean_alloc_ctor(0, 8, 0); -lean_ctor_set(x_770, 0, x_761); -lean_ctor_set(x_770, 1, x_762); -lean_ctor_set(x_770, 2, x_763); -lean_ctor_set(x_770, 3, x_769); -lean_ctor_set(x_770, 4, x_765); -lean_ctor_set(x_770, 5, x_766); -lean_ctor_set(x_770, 6, x_767); -lean_ctor_set(x_770, 7, x_768); -x_771 = lean_st_ref_take(x_8, x_9); -if (x_12 == 0) -{ -lean_object* x_964; lean_object* x_965; uint8_t x_966; -x_964 = lean_ctor_get(x_771, 0); -lean_inc(x_964); -x_965 = lean_ctor_get(x_771, 1); -lean_inc(x_965); -lean_dec(x_771); -x_966 = 0; -x_772 = x_966; -x_773 = x_964; -x_774 = x_965; -goto block_963; -} -else -{ -lean_object* x_967; lean_object* x_968; uint8_t x_969; -x_967 = lean_ctor_get(x_771, 0); -lean_inc(x_967); -x_968 = lean_ctor_get(x_771, 1); -lean_inc(x_968); -lean_dec(x_771); -x_969 = 1; -x_772 = x_969; -x_773 = x_967; -x_774 = x_968; -goto block_963; -} -block_963: -{ -lean_object* x_775; lean_object* x_776; lean_object* x_777; lean_object* x_778; lean_object* x_779; lean_object* x_780; lean_object* x_781; lean_object* x_782; lean_object* x_783; lean_object* x_784; lean_object* x_785; lean_object* x_786; lean_object* x_787; lean_object* x_788; lean_object* x_789; uint8_t x_790; uint8_t x_791; uint8_t x_792; lean_object* x_793; lean_object* x_794; lean_object* x_795; uint8_t x_796; lean_object* x_797; lean_object* x_798; -x_775 = lean_ctor_get(x_773, 0); -lean_inc(x_775); -x_776 = lean_ctor_get(x_773, 1); -lean_inc(x_776); -x_777 = lean_ctor_get(x_773, 2); -lean_inc(x_777); -x_778 = lean_ctor_get(x_773, 3); -lean_inc(x_778); -if (lean_is_exclusive(x_773)) { - lean_ctor_release(x_773, 0); - lean_ctor_release(x_773, 1); - lean_ctor_release(x_773, 2); - lean_ctor_release(x_773, 3); - x_779 = x_773; -} else { - lean_dec_ref(x_773); - x_779 = lean_box(0); -} -x_780 = lean_unsigned_to_nat(1u); -x_781 = lean_nat_add(x_776, x_780); -if (lean_is_scalar(x_779)) { - x_782 = lean_alloc_ctor(0, 4, 0); -} else { - x_782 = x_779; -} -lean_ctor_set(x_782, 0, x_775); -lean_ctor_set(x_782, 1, x_781); -lean_ctor_set(x_782, 2, x_777); -lean_ctor_set(x_782, 3, x_778); -x_783 = lean_st_ref_set(x_8, x_782, x_774); -x_784 = lean_ctor_get(x_783, 1); -lean_inc(x_784); -if (lean_is_exclusive(x_783)) { - lean_ctor_release(x_783, 0); - lean_ctor_release(x_783, 1); - x_785 = x_783; -} else { - lean_dec_ref(x_783); - x_785 = lean_box(0); -} -x_786 = lean_ctor_get(x_3, 0); -lean_inc(x_786); -x_787 = lean_ctor_get(x_3, 1); -lean_inc(x_787); -x_788 = lean_ctor_get(x_3, 2); -lean_inc(x_788); -x_789 = lean_ctor_get(x_3, 3); -lean_inc(x_789); -x_790 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); -x_791 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); -x_792 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); -x_793 = lean_ctor_get(x_3, 5); -lean_inc(x_793); -x_794 = lean_ctor_get(x_3, 6); -lean_inc(x_794); -x_795 = lean_ctor_get(x_3, 7); -lean_inc(x_795); -x_796 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); + lean_dec_ref(x_649); + x_651 = lean_box(0); +} +x_652 = lean_ctor_get(x_3, 0); +lean_inc(x_652); +x_653 = lean_ctor_get(x_3, 1); +lean_inc(x_653); +x_654 = lean_ctor_get(x_3, 2); +lean_inc(x_654); +x_655 = lean_ctor_get(x_3, 3); +lean_inc(x_655); +x_656 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); +x_657 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); +x_658 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); +x_659 = lean_ctor_get(x_3, 5); +lean_inc(x_659); +x_660 = lean_ctor_get(x_3, 6); +lean_inc(x_660); +x_661 = lean_ctor_get(x_3, 7); +lean_inc(x_661); +x_662 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); if (lean_is_exclusive(x_3)) { lean_ctor_release(x_3, 0); lean_ctor_release(x_3, 1); @@ -13217,834 +12608,2032 @@ if (lean_is_exclusive(x_3)) { lean_ctor_release(x_3, 5); lean_ctor_release(x_3, 6); lean_ctor_release(x_3, 7); - x_797 = x_3; + x_663 = x_3; } else { lean_dec_ref(x_3); - x_797 = lean_box(0); + x_663 = lean_box(0); } -if (lean_is_scalar(x_797)) { - x_798 = lean_alloc_ctor(0, 8, 4); +if (lean_is_scalar(x_663)) { + x_664 = lean_alloc_ctor(0, 8, 4); } else { - x_798 = x_797; + x_664 = x_663; } -lean_ctor_set(x_798, 0, x_786); -lean_ctor_set(x_798, 1, x_787); -lean_ctor_set(x_798, 2, x_788); -lean_ctor_set(x_798, 3, x_789); -lean_ctor_set(x_798, 4, x_776); -lean_ctor_set(x_798, 5, x_793); -lean_ctor_set(x_798, 6, x_794); -lean_ctor_set(x_798, 7, x_795); -lean_ctor_set_uint8(x_798, sizeof(void*)*8, x_790); -lean_ctor_set_uint8(x_798, sizeof(void*)*8 + 1, x_791); -lean_ctor_set_uint8(x_798, sizeof(void*)*8 + 2, x_792); -lean_ctor_set_uint8(x_798, sizeof(void*)*8 + 3, x_796); -if (x_772 == 0) +lean_ctor_set(x_664, 0, x_652); +lean_ctor_set(x_664, 1, x_653); +lean_ctor_set(x_664, 2, x_654); +lean_ctor_set(x_664, 3, x_655); +lean_ctor_set(x_664, 4, x_643); +lean_ctor_set(x_664, 5, x_659); +lean_ctor_set(x_664, 6, x_660); +lean_ctor_set(x_664, 7, x_661); +lean_ctor_set_uint8(x_664, sizeof(void*)*8, x_656); +lean_ctor_set_uint8(x_664, sizeof(void*)*8 + 1, x_657); +lean_ctor_set_uint8(x_664, sizeof(void*)*8 + 2, x_658); +lean_ctor_set_uint8(x_664, sizeof(void*)*8 + 3, x_662); +if (x_17 == 0) { -lean_object* x_799; uint8_t x_800; -x_799 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; -x_800 = lean_name_eq(x_10, x_799); -if (x_800 == 0) +lean_object* x_665; uint8_t x_666; +x_665 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; +x_666 = lean_name_eq(x_10, x_665); +if (x_666 == 0) { -lean_object* x_801; uint8_t x_802; -x_801 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; -x_802 = lean_name_eq(x_10, x_801); -if (x_802 == 0) +lean_object* x_667; uint8_t x_668; +x_667 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_668 = lean_name_eq(x_10, x_667); +if (x_668 == 0) { -lean_object* x_803; uint8_t x_804; -x_803 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; -x_804 = lean_name_eq(x_10, x_803); -if (x_804 == 0) +lean_object* x_669; uint8_t x_670; +x_669 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; +x_670 = lean_name_eq(x_10, x_669); +if (x_670 == 0) { -lean_object* x_805; uint8_t x_806; -x_805 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; -x_806 = lean_name_eq(x_10, x_805); -if (x_806 == 0) +lean_object* x_671; uint8_t x_672; +x_671 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; +x_672 = lean_name_eq(x_10, x_671); +if (x_672 == 0) { -lean_object* x_807; uint8_t x_808; -x_807 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; -x_808 = lean_name_eq(x_10, x_807); -if (x_808 == 0) +lean_object* x_673; uint8_t x_674; +x_673 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; +x_674 = lean_name_eq(x_10, x_673); +if (x_674 == 0) { -lean_object* x_809; uint8_t x_810; -x_809 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; -x_810 = lean_name_eq(x_10, x_809); -if (x_810 == 0) +lean_object* x_675; uint8_t x_676; +x_675 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_676 = lean_name_eq(x_10, x_675); +if (x_676 == 0) { -lean_object* x_811; uint8_t x_812; -x_811 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; -x_812 = lean_name_eq(x_10, x_811); -if (x_812 == 0) +lean_object* x_677; uint8_t x_678; +x_677 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; +x_678 = lean_name_eq(x_10, x_677); +if (x_678 == 0) { -lean_object* x_813; uint8_t x_814; -x_813 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; -x_814 = lean_name_eq(x_10, x_813); -if (x_814 == 0) +lean_object* x_679; uint8_t x_680; +x_679 = l_Lean_Parser_Term_binop___elambda__1___closed__2; +x_680 = lean_name_eq(x_10, x_679); +if (x_680 == 0) { -lean_object* x_815; uint8_t x_816; -x_815 = l_Lean_strLitKind; -x_816 = lean_name_eq(x_10, x_815); -if (x_816 == 0) +lean_object* x_681; uint8_t x_682; +x_681 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_682 = lean_name_eq(x_10, x_681); +if (x_682 == 0) { -lean_object* x_817; uint8_t x_818; -x_817 = l_Lean_numLitKind; -x_818 = lean_name_eq(x_10, x_817); -if (x_818 == 0) +lean_object* x_683; uint8_t x_684; +x_683 = l_Lean_strLitKind; +x_684 = lean_name_eq(x_10, x_683); +if (x_684 == 0) { -lean_object* x_819; uint8_t x_820; -x_819 = l_Lean_scientificLitKind; -x_820 = lean_name_eq(x_10, x_819); -if (x_820 == 0) +lean_object* x_685; uint8_t x_686; +x_685 = l_Lean_numLitKind; +x_686 = lean_name_eq(x_10, x_685); +if (x_686 == 0) { -lean_object* x_821; uint8_t x_822; -x_821 = l_Lean_charLitKind; -x_822 = lean_name_eq(x_10, x_821); -if (x_822 == 0) +lean_object* x_687; uint8_t x_688; +x_687 = l_Lean_scientificLitKind; +x_688 = lean_name_eq(x_10, x_687); +if (x_688 == 0) { -lean_object* x_823; uint8_t x_824; -lean_dec(x_785); -x_823 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; -x_824 = lean_name_eq(x_10, x_823); -if (x_824 == 0) +lean_object* x_689; uint8_t x_690; +x_689 = l_Lean_charLitKind; +x_690 = lean_name_eq(x_10, x_689); +if (x_690 == 0) { -lean_object* x_825; uint8_t x_826; -x_825 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; -x_826 = lean_name_eq(x_10, x_825); -if (x_826 == 0) +lean_object* x_691; uint8_t x_692; +lean_dec(x_651); +x_691 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_692 = lean_name_eq(x_10, x_691); +if (x_692 == 0) { -lean_object* x_827; uint8_t x_828; +lean_object* x_693; uint8_t x_694; +x_693 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; +x_694 = lean_name_eq(x_10, x_693); +if (x_694 == 0) +{ +lean_object* x_695; uint8_t x_696; lean_dec(x_1); -x_827 = l_Lean_choiceKind; -x_828 = lean_name_eq(x_10, x_827); +x_695 = l_Lean_choiceKind; +x_696 = lean_name_eq(x_10, x_695); lean_dec(x_10); -if (x_828 == 0) +if (x_696 == 0) { -lean_object* x_829; -x_829 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); +lean_object* x_697; +x_697 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); lean_dec(x_8); -lean_dec(x_770); +lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_798); +lean_dec(x_664); lean_dec(x_2); -return x_829; +return x_697; } else { -lean_object* x_830; lean_object* x_831; -x_830 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; -x_831 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_830, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); +lean_object* x_698; lean_object* x_699; +x_698 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; +x_699 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_698, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); lean_dec(x_8); -lean_dec(x_770); +lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_798); +lean_dec(x_664); lean_dec(x_2); -return x_831; +return x_699; } } else { -lean_object* x_832; +lean_object* x_700; lean_dec(x_10); lean_dec(x_2); -x_832 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_798, x_4, x_5, x_6, x_770, x_8, x_784); +x_700 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_664, x_4, x_5, x_6, x_7, x_8, x_650); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_1); -return x_832; +return x_700; } } else { -lean_object* x_833; +lean_object* x_701; lean_dec(x_10); lean_dec(x_2); -x_833 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_798, x_4, x_5, x_6, x_770, x_8, x_784); +x_701 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_664, x_4, x_5, x_6, x_7, x_8, x_650); lean_dec(x_8); -lean_dec(x_770); +lean_dec(x_7); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_1); -return x_833; +return x_701; } } else { -lean_object* x_834; -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_702; +lean_dec(x_664); +lean_dec(x_7); lean_dec(x_10); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_834 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_651)) { + x_702 = lean_alloc_ctor(0, 2, 0); } else { - x_834 = x_785; + x_702 = x_651; } -lean_ctor_set(x_834, 0, x_1); -lean_ctor_set(x_834, 1, x_784); -return x_834; +lean_ctor_set(x_702, 0, x_1); +lean_ctor_set(x_702, 1, x_650); +return x_702; } } else { -lean_object* x_835; -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_703; +lean_dec(x_664); +lean_dec(x_7); lean_dec(x_10); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_835 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_651)) { + x_703 = lean_alloc_ctor(0, 2, 0); } else { - x_835 = x_785; + x_703 = x_651; } -lean_ctor_set(x_835, 0, x_1); -lean_ctor_set(x_835, 1, x_784); -return x_835; +lean_ctor_set(x_703, 0, x_1); +lean_ctor_set(x_703, 1, x_650); +return x_703; } } else { -lean_object* x_836; -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_704; +lean_dec(x_664); +lean_dec(x_7); lean_dec(x_10); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_836 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_651)) { + x_704 = lean_alloc_ctor(0, 2, 0); } else { - x_836 = x_785; + x_704 = x_651; } -lean_ctor_set(x_836, 0, x_1); -lean_ctor_set(x_836, 1, x_784); -return x_836; +lean_ctor_set(x_704, 0, x_1); +lean_ctor_set(x_704, 1, x_650); +return x_704; } } else { -lean_object* x_837; -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_705; +lean_dec(x_664); +lean_dec(x_7); lean_dec(x_10); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_837 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_651)) { + x_705 = lean_alloc_ctor(0, 2, 0); } else { - x_837 = x_785; + x_705 = x_651; } -lean_ctor_set(x_837, 0, x_1); -lean_ctor_set(x_837, 1, x_784); -return x_837; +lean_ctor_set(x_705, 0, x_1); +lean_ctor_set(x_705, 1, x_650); +return x_705; } } else { -lean_object* x_838; -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_706; +lean_dec(x_664); +lean_dec(x_7); lean_dec(x_10); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_838 = lean_alloc_ctor(0, 2, 0); +if (lean_is_scalar(x_651)) { + x_706 = lean_alloc_ctor(0, 2, 0); } else { - x_838 = x_785; + x_706 = x_651; } -lean_ctor_set(x_838, 0, x_1); -lean_ctor_set(x_838, 1, x_784); -return x_838; +lean_ctor_set(x_706, 0, x_1); +lean_ctor_set(x_706, 1, x_650); +return x_706; } } else { -lean_object* x_839; lean_object* x_840; lean_object* x_841; -lean_dec(x_785); +lean_object* x_707; lean_object* x_708; lean_object* x_709; +lean_dec(x_651); lean_dec(x_10); -x_839 = lean_unsigned_to_nat(0u); -x_840 = l_Lean_Syntax_getArg(x_1, x_839); -lean_inc(x_770); -lean_inc(x_840); -x_841 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_840, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -if (lean_obj_tag(x_841) == 0) -{ -lean_object* x_842; lean_object* x_843; lean_object* x_844; lean_object* x_845; -x_842 = lean_ctor_get(x_841, 1); -lean_inc(x_842); -lean_dec(x_841); -x_843 = lean_unsigned_to_nat(2u); -x_844 = l_Lean_Syntax_getArg(x_1, x_843); -lean_dec(x_1); +x_707 = lean_unsigned_to_nat(2u); +x_708 = l_Lean_Syntax_getArg(x_1, x_707); lean_inc(x_8); -lean_inc(x_770); +lean_inc(x_7); lean_inc(x_6); lean_inc(x_5); lean_inc(x_4); -lean_inc(x_798); -x_845 = l_Lean_Elab_Term_CollectPatternVars_collect(x_844, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_842); -if (lean_obj_tag(x_845) == 0) +lean_inc(x_664); +lean_inc(x_2); +x_709 = l_Lean_Elab_Term_CollectPatternVars_collect(x_708, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +if (lean_obj_tag(x_709) == 0) { -lean_object* x_846; lean_object* x_847; lean_object* x_848; lean_object* x_849; lean_object* x_850; lean_object* x_851; lean_object* x_852; lean_object* x_853; lean_object* x_854; lean_object* x_855; lean_object* x_856; lean_object* x_857; lean_object* x_858; lean_object* x_859; lean_object* x_860; lean_object* x_861; lean_object* x_862; lean_object* x_863; lean_object* x_864; lean_object* x_865; lean_object* x_866; lean_object* x_867; lean_object* x_868; lean_object* x_869; lean_object* x_870; lean_object* x_871; -x_846 = lean_ctor_get(x_845, 0); -lean_inc(x_846); -x_847 = lean_ctor_get(x_845, 1); -lean_inc(x_847); -lean_dec(x_845); -x_848 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_770, x_8, x_847); -x_849 = lean_ctor_get(x_848, 0); -lean_inc(x_849); -x_850 = lean_ctor_get(x_848, 1); -lean_inc(x_850); -lean_dec(x_848); -x_851 = l_Lean_Elab_Term_getCurrMacroScope(x_798, x_4, x_5, x_6, x_770, x_8, x_850); -lean_dec(x_770); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_798); -x_852 = lean_ctor_get(x_851, 0); -lean_inc(x_852); -x_853 = lean_ctor_get(x_851, 1); -lean_inc(x_853); -lean_dec(x_851); -x_854 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_853); -lean_dec(x_8); -x_855 = lean_ctor_get(x_854, 0); -lean_inc(x_855); -x_856 = lean_ctor_get(x_854, 1); -lean_inc(x_856); -if (lean_is_exclusive(x_854)) { - lean_ctor_release(x_854, 0); - lean_ctor_release(x_854, 1); - x_857 = x_854; +lean_object* x_710; lean_object* x_711; lean_object* x_712; lean_object* x_713; lean_object* x_714; +x_710 = lean_ctor_get(x_709, 0); +lean_inc(x_710); +x_711 = lean_ctor_get(x_709, 1); +lean_inc(x_711); +lean_dec(x_709); +x_712 = lean_unsigned_to_nat(3u); +x_713 = l_Lean_Syntax_getArg(x_1, x_712); +x_714 = l_Lean_Elab_Term_CollectPatternVars_collect(x_713, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_711); +if (lean_obj_tag(x_714) == 0) +{ +lean_object* x_715; lean_object* x_716; lean_object* x_717; lean_object* x_718; lean_object* x_719; lean_object* x_720; +x_715 = lean_ctor_get(x_714, 0); +lean_inc(x_715); +x_716 = lean_ctor_get(x_714, 1); +lean_inc(x_716); +if (lean_is_exclusive(x_714)) { + lean_ctor_release(x_714, 0); + lean_ctor_release(x_714, 1); + x_717 = x_714; } else { - lean_dec_ref(x_854); - x_857 = lean_box(0); + lean_dec_ref(x_714); + x_717 = lean_box(0); } -x_858 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; -x_859 = l_Lean_addMacroScope(x_855, x_858, x_852); -x_860 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; -x_861 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; -x_862 = lean_alloc_ctor(3, 4, 0); -lean_ctor_set(x_862, 0, x_849); -lean_ctor_set(x_862, 1, x_860); -lean_ctor_set(x_862, 2, x_859); -lean_ctor_set(x_862, 3, x_861); -x_863 = l_Array_empty___closed__1; -x_864 = lean_array_push(x_863, x_862); -x_865 = lean_array_push(x_863, x_840); -x_866 = lean_array_push(x_865, x_846); -x_867 = l_Lean_nullKind___closed__2; -x_868 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_868, 0, x_867); -lean_ctor_set(x_868, 1, x_866); -x_869 = lean_array_push(x_864, x_868); -x_870 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_870, 0, x_799); -lean_ctor_set(x_870, 1, x_869); -if (lean_is_scalar(x_857)) { - x_871 = lean_alloc_ctor(0, 2, 0); +x_718 = l_Lean_Syntax_setArg(x_1, x_707, x_710); +x_719 = l_Lean_Syntax_setArg(x_718, x_712, x_715); +if (lean_is_scalar(x_717)) { + x_720 = lean_alloc_ctor(0, 2, 0); } else { - x_871 = x_857; + x_720 = x_717; } -lean_ctor_set(x_871, 0, x_870); -lean_ctor_set(x_871, 1, x_856); -return x_871; +lean_ctor_set(x_720, 0, x_719); +lean_ctor_set(x_720, 1, x_716); +return x_720; } else { -lean_object* x_872; lean_object* x_873; lean_object* x_874; lean_object* x_875; -lean_dec(x_840); -lean_dec(x_798); -lean_dec(x_770); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -x_872 = lean_ctor_get(x_845, 0); -lean_inc(x_872); -x_873 = lean_ctor_get(x_845, 1); -lean_inc(x_873); -if (lean_is_exclusive(x_845)) { - lean_ctor_release(x_845, 0); - lean_ctor_release(x_845, 1); - x_874 = x_845; +lean_object* x_721; lean_object* x_722; lean_object* x_723; lean_object* x_724; +lean_dec(x_710); +lean_dec(x_1); +x_721 = lean_ctor_get(x_714, 0); +lean_inc(x_721); +x_722 = lean_ctor_get(x_714, 1); +lean_inc(x_722); +if (lean_is_exclusive(x_714)) { + lean_ctor_release(x_714, 0); + lean_ctor_release(x_714, 1); + x_723 = x_714; } else { - lean_dec_ref(x_845); - x_874 = lean_box(0); + lean_dec_ref(x_714); + x_723 = lean_box(0); } -if (lean_is_scalar(x_874)) { - x_875 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_723)) { + x_724 = lean_alloc_ctor(1, 2, 0); } else { - x_875 = x_874; + x_724 = x_723; } -lean_ctor_set(x_875, 0, x_872); -lean_ctor_set(x_875, 1, x_873); -return x_875; +lean_ctor_set(x_724, 0, x_721); +lean_ctor_set(x_724, 1, x_722); +return x_724; } } else { -lean_object* x_876; lean_object* x_877; lean_object* x_878; lean_object* x_879; -lean_dec(x_840); -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_725; lean_object* x_726; lean_object* x_727; lean_object* x_728; +lean_dec(x_664); +lean_dec(x_7); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); lean_dec(x_1); -x_876 = lean_ctor_get(x_841, 0); -lean_inc(x_876); -x_877 = lean_ctor_get(x_841, 1); -lean_inc(x_877); -if (lean_is_exclusive(x_841)) { - lean_ctor_release(x_841, 0); - lean_ctor_release(x_841, 1); - x_878 = x_841; +x_725 = lean_ctor_get(x_709, 0); +lean_inc(x_725); +x_726 = lean_ctor_get(x_709, 1); +lean_inc(x_726); +if (lean_is_exclusive(x_709)) { + lean_ctor_release(x_709, 0); + lean_ctor_release(x_709, 1); + x_727 = x_709; } else { - lean_dec_ref(x_841); + lean_dec_ref(x_709); + x_727 = lean_box(0); +} +if (lean_is_scalar(x_727)) { + x_728 = lean_alloc_ctor(1, 2, 0); +} else { + x_728 = x_727; +} +lean_ctor_set(x_728, 0, x_725); +lean_ctor_set(x_728, 1, x_726); +return x_728; +} +} +} +else +{ +lean_object* x_729; lean_object* x_730; lean_object* x_731; +lean_dec(x_651); +lean_dec(x_10); +x_729 = lean_unsigned_to_nat(0u); +x_730 = l_Lean_Syntax_getArg(x_1, x_729); +lean_inc(x_7); +lean_inc(x_730); +x_731 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_730, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +if (lean_obj_tag(x_731) == 0) +{ +lean_object* x_732; lean_object* x_733; lean_object* x_734; lean_object* x_735; +x_732 = lean_ctor_get(x_731, 1); +lean_inc(x_732); +lean_dec(x_731); +x_733 = lean_unsigned_to_nat(2u); +x_734 = l_Lean_Syntax_getArg(x_1, x_733); +lean_dec(x_1); +lean_inc(x_8); +lean_inc(x_7); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_664); +x_735 = l_Lean_Elab_Term_CollectPatternVars_collect(x_734, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_732); +if (lean_obj_tag(x_735) == 0) +{ +lean_object* x_736; lean_object* x_737; lean_object* x_738; lean_object* x_739; lean_object* x_740; lean_object* x_741; lean_object* x_742; lean_object* x_743; lean_object* x_744; lean_object* x_745; lean_object* x_746; lean_object* x_747; lean_object* x_748; lean_object* x_749; lean_object* x_750; lean_object* x_751; lean_object* x_752; lean_object* x_753; lean_object* x_754; lean_object* x_755; lean_object* x_756; lean_object* x_757; lean_object* x_758; lean_object* x_759; lean_object* x_760; lean_object* x_761; +x_736 = lean_ctor_get(x_735, 0); +lean_inc(x_736); +x_737 = lean_ctor_get(x_735, 1); +lean_inc(x_737); +lean_dec(x_735); +x_738 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_7, x_8, x_737); +x_739 = lean_ctor_get(x_738, 0); +lean_inc(x_739); +x_740 = lean_ctor_get(x_738, 1); +lean_inc(x_740); +lean_dec(x_738); +x_741 = l_Lean_Elab_Term_getCurrMacroScope(x_664, x_4, x_5, x_6, x_7, x_8, x_740); +lean_dec(x_7); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_664); +x_742 = lean_ctor_get(x_741, 0); +lean_inc(x_742); +x_743 = lean_ctor_get(x_741, 1); +lean_inc(x_743); +lean_dec(x_741); +x_744 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_743); +lean_dec(x_8); +x_745 = lean_ctor_get(x_744, 0); +lean_inc(x_745); +x_746 = lean_ctor_get(x_744, 1); +lean_inc(x_746); +if (lean_is_exclusive(x_744)) { + lean_ctor_release(x_744, 0); + lean_ctor_release(x_744, 1); + x_747 = x_744; +} else { + lean_dec_ref(x_744); + x_747 = lean_box(0); +} +x_748 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; +x_749 = l_Lean_addMacroScope(x_745, x_748, x_742); +x_750 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; +x_751 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; +x_752 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_752, 0, x_739); +lean_ctor_set(x_752, 1, x_750); +lean_ctor_set(x_752, 2, x_749); +lean_ctor_set(x_752, 3, x_751); +x_753 = l_Array_empty___closed__1; +x_754 = lean_array_push(x_753, x_752); +x_755 = lean_array_push(x_753, x_730); +x_756 = lean_array_push(x_755, x_736); +x_757 = l_Lean_nullKind___closed__2; +x_758 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_758, 0, x_757); +lean_ctor_set(x_758, 1, x_756); +x_759 = lean_array_push(x_754, x_758); +x_760 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_760, 0, x_665); +lean_ctor_set(x_760, 1, x_759); +if (lean_is_scalar(x_747)) { + x_761 = lean_alloc_ctor(0, 2, 0); +} else { + x_761 = x_747; +} +lean_ctor_set(x_761, 0, x_760); +lean_ctor_set(x_761, 1, x_746); +return x_761; +} +else +{ +lean_object* x_762; lean_object* x_763; lean_object* x_764; lean_object* x_765; +lean_dec(x_730); +lean_dec(x_664); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_762 = lean_ctor_get(x_735, 0); +lean_inc(x_762); +x_763 = lean_ctor_get(x_735, 1); +lean_inc(x_763); +if (lean_is_exclusive(x_735)) { + lean_ctor_release(x_735, 0); + lean_ctor_release(x_735, 1); + x_764 = x_735; +} else { + lean_dec_ref(x_735); + x_764 = lean_box(0); +} +if (lean_is_scalar(x_764)) { + x_765 = lean_alloc_ctor(1, 2, 0); +} else { + x_765 = x_764; +} +lean_ctor_set(x_765, 0, x_762); +lean_ctor_set(x_765, 1, x_763); +return x_765; +} +} +else +{ +lean_object* x_766; lean_object* x_767; lean_object* x_768; lean_object* x_769; +lean_dec(x_730); +lean_dec(x_664); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_766 = lean_ctor_get(x_731, 0); +lean_inc(x_766); +x_767 = lean_ctor_get(x_731, 1); +lean_inc(x_767); +if (lean_is_exclusive(x_731)) { + lean_ctor_release(x_731, 0); + lean_ctor_release(x_731, 1); + x_768 = x_731; +} else { + lean_dec_ref(x_731); + x_768 = lean_box(0); +} +if (lean_is_scalar(x_768)) { + x_769 = lean_alloc_ctor(1, 2, 0); +} else { + x_769 = x_768; +} +lean_ctor_set(x_769, 0, x_766); +lean_ctor_set(x_769, 1, x_767); +return x_769; +} +} +} +else +{ +lean_object* x_770; lean_object* x_771; lean_object* x_772; +lean_dec(x_651); +lean_dec(x_10); +x_770 = lean_unsigned_to_nat(0u); +x_771 = l_Lean_Syntax_getArg(x_1, x_770); +lean_dec(x_1); +x_772 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_771, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +return x_772; +} +} +else +{ +lean_object* x_773; uint8_t x_774; +lean_dec(x_10); +x_773 = l_Lean_Syntax_getArg(x_1, x_646); +x_774 = l_Lean_Syntax_isNone(x_773); +if (x_774 == 0) +{ +lean_object* x_775; lean_object* x_776; lean_object* x_777; uint8_t x_778; +x_775 = lean_unsigned_to_nat(0u); +x_776 = l_Lean_Syntax_getArg(x_773, x_775); +x_777 = l_Lean_Syntax_getArg(x_773, x_646); +x_778 = l_Lean_Syntax_isNone(x_777); +if (x_778 == 0) +{ +lean_object* x_779; lean_object* x_780; lean_object* x_781; uint8_t x_782; +x_779 = l_Lean_Syntax_getArg(x_777, x_775); +lean_dec(x_777); +x_780 = l_Lean_Syntax_getKind(x_779); +x_781 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; +x_782 = lean_name_eq(x_780, x_781); +lean_dec(x_780); +if (x_782 == 0) +{ +lean_object* x_783; +lean_dec(x_776); +lean_dec(x_773); +lean_dec(x_664); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_651)) { + x_783 = lean_alloc_ctor(0, 2, 0); +} else { + x_783 = x_651; +} +lean_ctor_set(x_783, 0, x_1); +lean_ctor_set(x_783, 1, x_650); +return x_783; +} +else +{ +lean_object* x_784; +lean_dec(x_651); +x_784 = l_Lean_Elab_Term_CollectPatternVars_collect(x_776, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +if (lean_obj_tag(x_784) == 0) +{ +lean_object* x_785; lean_object* x_786; lean_object* x_787; lean_object* x_788; lean_object* x_789; lean_object* x_790; +x_785 = lean_ctor_get(x_784, 0); +lean_inc(x_785); +x_786 = lean_ctor_get(x_784, 1); +lean_inc(x_786); +if (lean_is_exclusive(x_784)) { + lean_ctor_release(x_784, 0); + lean_ctor_release(x_784, 1); + x_787 = x_784; +} else { + lean_dec_ref(x_784); + x_787 = lean_box(0); +} +x_788 = l_Lean_Syntax_setArg(x_773, x_775, x_785); +x_789 = l_Lean_Syntax_setArg(x_1, x_646, x_788); +if (lean_is_scalar(x_787)) { + x_790 = lean_alloc_ctor(0, 2, 0); +} else { + x_790 = x_787; +} +lean_ctor_set(x_790, 0, x_789); +lean_ctor_set(x_790, 1, x_786); +return x_790; +} +else +{ +lean_object* x_791; lean_object* x_792; lean_object* x_793; lean_object* x_794; +lean_dec(x_773); +lean_dec(x_1); +x_791 = lean_ctor_get(x_784, 0); +lean_inc(x_791); +x_792 = lean_ctor_get(x_784, 1); +lean_inc(x_792); +if (lean_is_exclusive(x_784)) { + lean_ctor_release(x_784, 0); + lean_ctor_release(x_784, 1); + x_793 = x_784; +} else { + lean_dec_ref(x_784); + x_793 = lean_box(0); +} +if (lean_is_scalar(x_793)) { + x_794 = lean_alloc_ctor(1, 2, 0); +} else { + x_794 = x_793; +} +lean_ctor_set(x_794, 0, x_791); +lean_ctor_set(x_794, 1, x_792); +return x_794; +} +} +} +else +{ +lean_object* x_795; +lean_dec(x_777); +lean_dec(x_651); +x_795 = l_Lean_Elab_Term_CollectPatternVars_collect(x_776, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +if (lean_obj_tag(x_795) == 0) +{ +lean_object* x_796; lean_object* x_797; lean_object* x_798; lean_object* x_799; lean_object* x_800; lean_object* x_801; +x_796 = lean_ctor_get(x_795, 0); +lean_inc(x_796); +x_797 = lean_ctor_get(x_795, 1); +lean_inc(x_797); +if (lean_is_exclusive(x_795)) { + lean_ctor_release(x_795, 0); + lean_ctor_release(x_795, 1); + x_798 = x_795; +} else { + lean_dec_ref(x_795); + x_798 = lean_box(0); +} +x_799 = l_Lean_Syntax_setArg(x_773, x_775, x_796); +x_800 = l_Lean_Syntax_setArg(x_1, x_646, x_799); +if (lean_is_scalar(x_798)) { + x_801 = lean_alloc_ctor(0, 2, 0); +} else { + x_801 = x_798; +} +lean_ctor_set(x_801, 0, x_800); +lean_ctor_set(x_801, 1, x_797); +return x_801; +} +else +{ +lean_object* x_802; lean_object* x_803; lean_object* x_804; lean_object* x_805; +lean_dec(x_773); +lean_dec(x_1); +x_802 = lean_ctor_get(x_795, 0); +lean_inc(x_802); +x_803 = lean_ctor_get(x_795, 1); +lean_inc(x_803); +if (lean_is_exclusive(x_795)) { + lean_ctor_release(x_795, 0); + lean_ctor_release(x_795, 1); + x_804 = x_795; +} else { + lean_dec_ref(x_795); + x_804 = lean_box(0); +} +if (lean_is_scalar(x_804)) { + x_805 = lean_alloc_ctor(1, 2, 0); +} else { + x_805 = x_804; +} +lean_ctor_set(x_805, 0, x_802); +lean_ctor_set(x_805, 1, x_803); +return x_805; +} +} +} +else +{ +lean_object* x_806; +lean_dec(x_773); +lean_dec(x_664); +lean_dec(x_7); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_651)) { + x_806 = lean_alloc_ctor(0, 2, 0); +} else { + x_806 = x_651; +} +lean_ctor_set(x_806, 0, x_1); +lean_ctor_set(x_806, 1, x_650); +return x_806; +} +} +} +else +{ +lean_object* x_807; lean_object* x_808; lean_object* x_809; lean_object* x_810; lean_object* x_811; lean_object* x_812; lean_object* x_813; lean_object* x_814; lean_object* x_815; lean_object* x_816; lean_object* x_817; lean_object* x_818; lean_object* x_819; lean_object* x_820; lean_object* x_821; lean_object* x_822; lean_object* x_823; lean_object* x_824; lean_object* x_825; +lean_dec(x_664); +lean_dec(x_651); +lean_dec(x_7); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_807 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_650); +x_808 = lean_ctor_get(x_807, 0); +lean_inc(x_808); +x_809 = lean_ctor_get(x_807, 1); +lean_inc(x_809); +lean_dec(x_807); +x_810 = lean_st_ref_get(x_8, x_809); +lean_dec(x_8); +x_811 = lean_ctor_get(x_810, 1); +lean_inc(x_811); +lean_dec(x_810); +x_812 = lean_st_ref_take(x_2, x_811); +x_813 = lean_ctor_get(x_812, 0); +lean_inc(x_813); +x_814 = lean_ctor_get(x_812, 1); +lean_inc(x_814); +lean_dec(x_812); +x_815 = lean_ctor_get(x_813, 0); +lean_inc(x_815); +x_816 = lean_ctor_get(x_813, 1); +lean_inc(x_816); +if (lean_is_exclusive(x_813)) { + lean_ctor_release(x_813, 0); + lean_ctor_release(x_813, 1); + x_817 = x_813; +} else { + lean_dec_ref(x_813); + x_817 = lean_box(0); +} +x_818 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_808); +x_819 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_819, 0, x_818); +x_820 = lean_array_push(x_816, x_819); +if (lean_is_scalar(x_817)) { + x_821 = lean_alloc_ctor(0, 2, 0); +} else { + x_821 = x_817; +} +lean_ctor_set(x_821, 0, x_815); +lean_ctor_set(x_821, 1, x_820); +x_822 = lean_st_ref_set(x_2, x_821, x_814); +lean_dec(x_2); +x_823 = lean_ctor_get(x_822, 1); +lean_inc(x_823); +if (lean_is_exclusive(x_822)) { + lean_ctor_release(x_822, 0); + lean_ctor_release(x_822, 1); + x_824 = x_822; +} else { + lean_dec_ref(x_822); + x_824 = lean_box(0); +} +if (lean_is_scalar(x_824)) { + x_825 = lean_alloc_ctor(0, 2, 0); +} else { + x_825 = x_824; +} +lean_ctor_set(x_825, 0, x_808); +lean_ctor_set(x_825, 1, x_823); +return x_825; +} +} +else +{ +lean_object* x_826; uint8_t x_827; +lean_dec(x_651); +lean_dec(x_10); +x_826 = l_Lean_Syntax_getArg(x_1, x_646); +x_827 = l_Lean_Syntax_isNone(x_826); +if (x_827 == 0) +{ +lean_object* x_828; lean_object* x_829; lean_object* x_830; lean_object* x_831; lean_object* x_832; lean_object* x_833; +lean_dec(x_1); +x_828 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; +x_829 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_826, x_828, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_664); +lean_dec(x_2); +lean_dec(x_826); +x_830 = lean_ctor_get(x_829, 0); +lean_inc(x_830); +x_831 = lean_ctor_get(x_829, 1); +lean_inc(x_831); +if (lean_is_exclusive(x_829)) { + lean_ctor_release(x_829, 0); + lean_ctor_release(x_829, 1); + x_832 = x_829; +} else { + lean_dec_ref(x_829); + x_832 = lean_box(0); +} +if (lean_is_scalar(x_832)) { + x_833 = lean_alloc_ctor(1, 2, 0); +} else { + x_833 = x_832; +} +lean_ctor_set(x_833, 0, x_830); +lean_ctor_set(x_833, 1, x_831); +return x_833; +} +else +{ +lean_object* x_834; lean_object* x_835; +lean_dec(x_826); +x_834 = lean_box(0); +x_835 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_834, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +return x_835; +} +} +} +else +{ +lean_object* x_836; lean_object* x_837; lean_object* x_838; lean_object* x_839; +lean_dec(x_651); +lean_dec(x_10); +x_836 = l_Lean_Syntax_getArg(x_1, x_646); +x_837 = l_Lean_Syntax_getArgs(x_836); +lean_dec(x_836); +x_838 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; +x_839 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_837, x_838, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +lean_dec(x_837); +if (lean_obj_tag(x_839) == 0) +{ +lean_object* x_840; lean_object* x_841; lean_object* x_842; lean_object* x_843; lean_object* x_844; lean_object* x_845; lean_object* x_846; +x_840 = lean_ctor_get(x_839, 0); +lean_inc(x_840); +x_841 = lean_ctor_get(x_839, 1); +lean_inc(x_841); +if (lean_is_exclusive(x_839)) { + lean_ctor_release(x_839, 0); + lean_ctor_release(x_839, 1); + x_842 = x_839; +} else { + lean_dec_ref(x_839); + x_842 = lean_box(0); +} +x_843 = l_Lean_nullKind; +x_844 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_844, 0, x_843); +lean_ctor_set(x_844, 1, x_840); +x_845 = l_Lean_Syntax_setArg(x_1, x_646, x_844); +if (lean_is_scalar(x_842)) { + x_846 = lean_alloc_ctor(0, 2, 0); +} else { + x_846 = x_842; +} +lean_ctor_set(x_846, 0, x_845); +lean_ctor_set(x_846, 1, x_841); +return x_846; +} +else +{ +lean_object* x_847; lean_object* x_848; lean_object* x_849; lean_object* x_850; +lean_dec(x_1); +x_847 = lean_ctor_get(x_839, 0); +lean_inc(x_847); +x_848 = lean_ctor_get(x_839, 1); +lean_inc(x_848); +if (lean_is_exclusive(x_839)) { + lean_ctor_release(x_839, 0); + lean_ctor_release(x_839, 1); + x_849 = x_839; +} else { + lean_dec_ref(x_839); + x_849 = lean_box(0); +} +if (lean_is_scalar(x_849)) { + x_850 = lean_alloc_ctor(1, 2, 0); +} else { + x_850 = x_849; +} +lean_ctor_set(x_850, 0, x_847); +lean_ctor_set(x_850, 1, x_848); +return x_850; +} +} +} +else +{ +lean_object* x_851; +lean_dec(x_651); +lean_dec(x_10); +x_851 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +lean_dec(x_1); +return x_851; +} +} +else +{ +lean_object* x_852; +lean_dec(x_651); +lean_dec(x_10); +x_852 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_664, x_4, x_5, x_6, x_7, x_8, x_650); +return x_852; +} +} +} +} +else +{ +lean_object* x_860; lean_object* x_861; lean_object* x_862; lean_object* x_863; lean_object* x_864; lean_object* x_865; lean_object* x_866; lean_object* x_867; lean_object* x_868; lean_object* x_869; lean_object* x_870; uint8_t x_871; lean_object* x_872; lean_object* x_873; +x_860 = lean_ctor_get(x_7, 0); +x_861 = lean_ctor_get(x_7, 1); +x_862 = lean_ctor_get(x_7, 2); +x_863 = lean_ctor_get(x_7, 3); +x_864 = lean_ctor_get(x_7, 4); +x_865 = lean_ctor_get(x_7, 5); +x_866 = lean_ctor_get(x_7, 6); +x_867 = lean_ctor_get(x_7, 7); +lean_inc(x_867); +lean_inc(x_866); +lean_inc(x_865); +lean_inc(x_864); +lean_inc(x_863); +lean_inc(x_862); +lean_inc(x_861); +lean_inc(x_860); +lean_dec(x_7); +x_868 = l_Lean_replaceRef(x_1, x_863); +lean_dec(x_863); +x_869 = lean_alloc_ctor(0, 8, 0); +lean_ctor_set(x_869, 0, x_860); +lean_ctor_set(x_869, 1, x_861); +lean_ctor_set(x_869, 2, x_862); +lean_ctor_set(x_869, 3, x_868); +lean_ctor_set(x_869, 4, x_864); +lean_ctor_set(x_869, 5, x_865); +lean_ctor_set(x_869, 6, x_866); +lean_ctor_set(x_869, 7, x_867); +x_870 = lean_st_ref_take(x_8, x_9); +if (x_12 == 0) +{ +lean_object* x_1087; lean_object* x_1088; uint8_t x_1089; +x_1087 = lean_ctor_get(x_870, 0); +lean_inc(x_1087); +x_1088 = lean_ctor_get(x_870, 1); +lean_inc(x_1088); +lean_dec(x_870); +x_1089 = 0; +x_871 = x_1089; +x_872 = x_1087; +x_873 = x_1088; +goto block_1086; +} +else +{ +lean_object* x_1090; lean_object* x_1091; uint8_t x_1092; +x_1090 = lean_ctor_get(x_870, 0); +lean_inc(x_1090); +x_1091 = lean_ctor_get(x_870, 1); +lean_inc(x_1091); +lean_dec(x_870); +x_1092 = 1; +x_871 = x_1092; +x_872 = x_1090; +x_873 = x_1091; +goto block_1086; +} +block_1086: +{ +lean_object* x_874; lean_object* x_875; lean_object* x_876; lean_object* x_877; lean_object* x_878; lean_object* x_879; lean_object* x_880; lean_object* x_881; lean_object* x_882; lean_object* x_883; lean_object* x_884; lean_object* x_885; lean_object* x_886; lean_object* x_887; lean_object* x_888; uint8_t x_889; uint8_t x_890; uint8_t x_891; lean_object* x_892; lean_object* x_893; lean_object* x_894; uint8_t x_895; lean_object* x_896; lean_object* x_897; +x_874 = lean_ctor_get(x_872, 0); +lean_inc(x_874); +x_875 = lean_ctor_get(x_872, 1); +lean_inc(x_875); +x_876 = lean_ctor_get(x_872, 2); +lean_inc(x_876); +x_877 = lean_ctor_get(x_872, 3); +lean_inc(x_877); +if (lean_is_exclusive(x_872)) { + lean_ctor_release(x_872, 0); + lean_ctor_release(x_872, 1); + lean_ctor_release(x_872, 2); + lean_ctor_release(x_872, 3); + x_878 = x_872; +} else { + lean_dec_ref(x_872); x_878 = lean_box(0); } +x_879 = lean_unsigned_to_nat(1u); +x_880 = lean_nat_add(x_875, x_879); if (lean_is_scalar(x_878)) { - x_879 = lean_alloc_ctor(1, 2, 0); + x_881 = lean_alloc_ctor(0, 4, 0); } else { - x_879 = x_878; + x_881 = x_878; } -lean_ctor_set(x_879, 0, x_876); -lean_ctor_set(x_879, 1, x_877); -return x_879; +lean_ctor_set(x_881, 0, x_874); +lean_ctor_set(x_881, 1, x_880); +lean_ctor_set(x_881, 2, x_876); +lean_ctor_set(x_881, 3, x_877); +x_882 = lean_st_ref_set(x_8, x_881, x_873); +x_883 = lean_ctor_get(x_882, 1); +lean_inc(x_883); +if (lean_is_exclusive(x_882)) { + lean_ctor_release(x_882, 0); + lean_ctor_release(x_882, 1); + x_884 = x_882; +} else { + lean_dec_ref(x_882); + x_884 = lean_box(0); } +x_885 = lean_ctor_get(x_3, 0); +lean_inc(x_885); +x_886 = lean_ctor_get(x_3, 1); +lean_inc(x_886); +x_887 = lean_ctor_get(x_3, 2); +lean_inc(x_887); +x_888 = lean_ctor_get(x_3, 3); +lean_inc(x_888); +x_889 = lean_ctor_get_uint8(x_3, sizeof(void*)*8); +x_890 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 1); +x_891 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 2); +x_892 = lean_ctor_get(x_3, 5); +lean_inc(x_892); +x_893 = lean_ctor_get(x_3, 6); +lean_inc(x_893); +x_894 = lean_ctor_get(x_3, 7); +lean_inc(x_894); +x_895 = lean_ctor_get_uint8(x_3, sizeof(void*)*8 + 3); +if (lean_is_exclusive(x_3)) { + lean_ctor_release(x_3, 0); + lean_ctor_release(x_3, 1); + lean_ctor_release(x_3, 2); + lean_ctor_release(x_3, 3); + lean_ctor_release(x_3, 4); + lean_ctor_release(x_3, 5); + lean_ctor_release(x_3, 6); + lean_ctor_release(x_3, 7); + x_896 = x_3; +} else { + lean_dec_ref(x_3); + x_896 = lean_box(0); } +if (lean_is_scalar(x_896)) { + x_897 = lean_alloc_ctor(0, 8, 4); +} else { + x_897 = x_896; } -else +lean_ctor_set(x_897, 0, x_885); +lean_ctor_set(x_897, 1, x_886); +lean_ctor_set(x_897, 2, x_887); +lean_ctor_set(x_897, 3, x_888); +lean_ctor_set(x_897, 4, x_875); +lean_ctor_set(x_897, 5, x_892); +lean_ctor_set(x_897, 6, x_893); +lean_ctor_set(x_897, 7, x_894); +lean_ctor_set_uint8(x_897, sizeof(void*)*8, x_889); +lean_ctor_set_uint8(x_897, sizeof(void*)*8 + 1, x_890); +lean_ctor_set_uint8(x_897, sizeof(void*)*8 + 2, x_891); +lean_ctor_set_uint8(x_897, sizeof(void*)*8 + 3, x_895); +if (x_871 == 0) { -lean_object* x_880; lean_object* x_881; lean_object* x_882; -lean_dec(x_785); -lean_dec(x_10); -x_880 = lean_unsigned_to_nat(0u); -x_881 = l_Lean_Syntax_getArg(x_1, x_880); +lean_object* x_898; uint8_t x_899; +x_898 = l_myMacro____x40_Init_Notation___hyg_2278____closed__4; +x_899 = lean_name_eq(x_10, x_898); +if (x_899 == 0) +{ +lean_object* x_900; uint8_t x_901; +x_900 = l_Lean_Parser_Term_anonymousCtor___elambda__1___closed__2; +x_901 = lean_name_eq(x_10, x_900); +if (x_901 == 0) +{ +lean_object* x_902; uint8_t x_903; +x_902 = l_Std_Range_myMacro____x40_Init_Data_Range___hyg_375____closed__2; +x_903 = lean_name_eq(x_10, x_902); +if (x_903 == 0) +{ +lean_object* x_904; uint8_t x_905; +x_904 = l_myMacro____x40_Init_Notation___hyg_14110____closed__13; +x_905 = lean_name_eq(x_10, x_904); +if (x_905 == 0) +{ +lean_object* x_906; uint8_t x_907; +x_906 = l_myMacro____x40_Init_Notation___hyg_13502____closed__8; +x_907 = lean_name_eq(x_10, x_906); +if (x_907 == 0) +{ +lean_object* x_908; uint8_t x_909; +x_908 = l_Lean_Parser_Term_explicitUniv___elambda__1___closed__2; +x_909 = lean_name_eq(x_10, x_908); +if (x_909 == 0) +{ +lean_object* x_910; uint8_t x_911; +x_910 = l_Lean_Parser_Term_namedPattern___elambda__1___closed__2; +x_911 = lean_name_eq(x_10, x_910); +if (x_911 == 0) +{ +lean_object* x_912; uint8_t x_913; +x_912 = l_Lean_Parser_Term_binop___elambda__1___closed__2; +x_913 = lean_name_eq(x_10, x_912); +if (x_913 == 0) +{ +lean_object* x_914; uint8_t x_915; +x_914 = l_Lean_Parser_Term_inaccessible___elambda__1___closed__2; +x_915 = lean_name_eq(x_10, x_914); +if (x_915 == 0) +{ +lean_object* x_916; uint8_t x_917; +x_916 = l_Lean_strLitKind; +x_917 = lean_name_eq(x_10, x_916); +if (x_917 == 0) +{ +lean_object* x_918; uint8_t x_919; +x_918 = l_Lean_numLitKind; +x_919 = lean_name_eq(x_10, x_918); +if (x_919 == 0) +{ +lean_object* x_920; uint8_t x_921; +x_920 = l_Lean_scientificLitKind; +x_921 = lean_name_eq(x_10, x_920); +if (x_921 == 0) +{ +lean_object* x_922; uint8_t x_923; +x_922 = l_Lean_charLitKind; +x_923 = lean_name_eq(x_10, x_922); +if (x_923 == 0) +{ +lean_object* x_924; uint8_t x_925; +lean_dec(x_884); +x_924 = l_Lean_Parser_Term_quotedName___elambda__1___closed__2; +x_925 = lean_name_eq(x_10, x_924); +if (x_925 == 0) +{ +lean_object* x_926; uint8_t x_927; +x_926 = l_Lean_Parser_Term_doubleQuotedName___elambda__1___closed__2; +x_927 = lean_name_eq(x_10, x_926); +if (x_927 == 0) +{ +lean_object* x_928; uint8_t x_929; lean_dec(x_1); -x_882 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_881, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -return x_882; +x_928 = l_Lean_choiceKind; +x_929 = lean_name_eq(x_10, x_928); +lean_dec(x_10); +if (x_929 == 0) +{ +lean_object* x_930; +x_930 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_throwInvalidPattern___rarg(x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_8); +lean_dec(x_869); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_897); +lean_dec(x_2); +return x_930; +} +else +{ +lean_object* x_931; lean_object* x_932; +x_931 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__2; +x_932 = l_Lean_throwError___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_finalize___spec__1(x_931, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_8); +lean_dec(x_869); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_897); +lean_dec(x_2); +return x_932; } } else { -lean_object* x_883; uint8_t x_884; +lean_object* x_933; lean_dec(x_10); -x_883 = l_Lean_Syntax_getArg(x_1, x_780); -x_884 = l_Lean_Syntax_isNone(x_883); -if (x_884 == 0) +lean_dec(x_2); +x_933 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_doubleQuotedNameToPattern(x_1, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_933; +} +} +else { -lean_object* x_885; lean_object* x_886; lean_object* x_887; uint8_t x_888; -x_885 = lean_unsigned_to_nat(0u); -x_886 = l_Lean_Syntax_getArg(x_883, x_885); -x_887 = l_Lean_Syntax_getArg(x_883, x_780); -x_888 = l_Lean_Syntax_isNone(x_887); -if (x_888 == 0) +lean_object* x_934; +lean_dec(x_10); +lean_dec(x_2); +x_934 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_quotedNameToPattern(x_1, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_8); +lean_dec(x_869); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +return x_934; +} +} +else { -lean_object* x_889; lean_object* x_890; lean_object* x_891; uint8_t x_892; -x_889 = l_Lean_Syntax_getArg(x_887, x_885); -lean_dec(x_887); -x_890 = l_Lean_Syntax_getKind(x_889); -x_891 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; -x_892 = lean_name_eq(x_890, x_891); -lean_dec(x_890); -if (x_892 == 0) -{ -lean_object* x_893; -lean_dec(x_886); -lean_dec(x_883); -lean_dec(x_798); -lean_dec(x_770); +lean_object* x_935; +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_10); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_893 = lean_alloc_ctor(0, 2, 0); -} else { - x_893 = x_785; -} -lean_ctor_set(x_893, 0, x_1); -lean_ctor_set(x_893, 1, x_784); -return x_893; -} -else -{ -lean_object* x_894; -lean_dec(x_785); -x_894 = l_Lean_Elab_Term_CollectPatternVars_collect(x_886, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -if (lean_obj_tag(x_894) == 0) -{ -lean_object* x_895; lean_object* x_896; lean_object* x_897; lean_object* x_898; lean_object* x_899; lean_object* x_900; -x_895 = lean_ctor_get(x_894, 0); -lean_inc(x_895); -x_896 = lean_ctor_get(x_894, 1); -lean_inc(x_896); -if (lean_is_exclusive(x_894)) { - lean_ctor_release(x_894, 0); - lean_ctor_release(x_894, 1); - x_897 = x_894; -} else { - lean_dec_ref(x_894); - x_897 = lean_box(0); -} -x_898 = l_Lean_Syntax_setArg(x_883, x_885, x_895); -x_899 = l_Lean_Syntax_setArg(x_1, x_780, x_898); -if (lean_is_scalar(x_897)) { - x_900 = lean_alloc_ctor(0, 2, 0); -} else { - x_900 = x_897; -} -lean_ctor_set(x_900, 0, x_899); -lean_ctor_set(x_900, 1, x_896); -return x_900; -} -else -{ -lean_object* x_901; lean_object* x_902; lean_object* x_903; lean_object* x_904; -lean_dec(x_883); -lean_dec(x_1); -x_901 = lean_ctor_get(x_894, 0); -lean_inc(x_901); -x_902 = lean_ctor_get(x_894, 1); -lean_inc(x_902); -if (lean_is_exclusive(x_894)) { - lean_ctor_release(x_894, 0); - lean_ctor_release(x_894, 1); - x_903 = x_894; -} else { - lean_dec_ref(x_894); - x_903 = lean_box(0); -} -if (lean_is_scalar(x_903)) { - x_904 = lean_alloc_ctor(1, 2, 0); -} else { - x_904 = x_903; -} -lean_ctor_set(x_904, 0, x_901); -lean_ctor_set(x_904, 1, x_902); -return x_904; -} -} -} -else -{ -lean_object* x_905; -lean_dec(x_887); -lean_dec(x_785); -x_905 = l_Lean_Elab_Term_CollectPatternVars_collect(x_886, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -if (lean_obj_tag(x_905) == 0) -{ -lean_object* x_906; lean_object* x_907; lean_object* x_908; lean_object* x_909; lean_object* x_910; lean_object* x_911; -x_906 = lean_ctor_get(x_905, 0); -lean_inc(x_906); -x_907 = lean_ctor_get(x_905, 1); -lean_inc(x_907); -if (lean_is_exclusive(x_905)) { - lean_ctor_release(x_905, 0); - lean_ctor_release(x_905, 1); - x_908 = x_905; -} else { - lean_dec_ref(x_905); - x_908 = lean_box(0); -} -x_909 = l_Lean_Syntax_setArg(x_883, x_885, x_906); -x_910 = l_Lean_Syntax_setArg(x_1, x_780, x_909); -if (lean_is_scalar(x_908)) { - x_911 = lean_alloc_ctor(0, 2, 0); -} else { - x_911 = x_908; -} -lean_ctor_set(x_911, 0, x_910); -lean_ctor_set(x_911, 1, x_907); -return x_911; -} -else -{ -lean_object* x_912; lean_object* x_913; lean_object* x_914; lean_object* x_915; -lean_dec(x_883); -lean_dec(x_1); -x_912 = lean_ctor_get(x_905, 0); -lean_inc(x_912); -x_913 = lean_ctor_get(x_905, 1); -lean_inc(x_913); -if (lean_is_exclusive(x_905)) { - lean_ctor_release(x_905, 0); - lean_ctor_release(x_905, 1); - x_914 = x_905; -} else { - lean_dec_ref(x_905); - x_914 = lean_box(0); -} -if (lean_is_scalar(x_914)) { - x_915 = lean_alloc_ctor(1, 2, 0); -} else { - x_915 = x_914; -} -lean_ctor_set(x_915, 0, x_912); -lean_ctor_set(x_915, 1, x_913); -return x_915; -} -} -} -else -{ -lean_object* x_916; -lean_dec(x_883); -lean_dec(x_798); -lean_dec(x_770); -lean_dec(x_8); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_2); -if (lean_is_scalar(x_785)) { - x_916 = lean_alloc_ctor(0, 2, 0); -} else { - x_916 = x_785; -} -lean_ctor_set(x_916, 0, x_1); -lean_ctor_set(x_916, 1, x_784); -return x_916; -} -} -} -else -{ -lean_object* x_917; lean_object* x_918; lean_object* x_919; lean_object* x_920; lean_object* x_921; lean_object* x_922; lean_object* x_923; lean_object* x_924; lean_object* x_925; lean_object* x_926; lean_object* x_927; lean_object* x_928; lean_object* x_929; lean_object* x_930; lean_object* x_931; lean_object* x_932; lean_object* x_933; lean_object* x_934; lean_object* x_935; -lean_dec(x_798); -lean_dec(x_785); -lean_dec(x_770); -lean_dec(x_10); -lean_dec(x_6); -lean_dec(x_5); -lean_dec(x_4); -lean_dec(x_1); -x_917 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_784); -x_918 = lean_ctor_get(x_917, 0); -lean_inc(x_918); -x_919 = lean_ctor_get(x_917, 1); -lean_inc(x_919); -lean_dec(x_917); -x_920 = lean_st_ref_get(x_8, x_919); -lean_dec(x_8); -x_921 = lean_ctor_get(x_920, 1); -lean_inc(x_921); -lean_dec(x_920); -x_922 = lean_st_ref_take(x_2, x_921); -x_923 = lean_ctor_get(x_922, 0); -lean_inc(x_923); -x_924 = lean_ctor_get(x_922, 1); -lean_inc(x_924); -lean_dec(x_922); -x_925 = lean_ctor_get(x_923, 0); -lean_inc(x_925); -x_926 = lean_ctor_get(x_923, 1); -lean_inc(x_926); -if (lean_is_exclusive(x_923)) { - lean_ctor_release(x_923, 0); - lean_ctor_release(x_923, 1); - x_927 = x_923; -} else { - lean_dec_ref(x_923); - x_927 = lean_box(0); -} -x_928 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_918); -x_929 = lean_alloc_ctor(1, 1, 0); -lean_ctor_set(x_929, 0, x_928); -x_930 = lean_array_push(x_926, x_929); -if (lean_is_scalar(x_927)) { - x_931 = lean_alloc_ctor(0, 2, 0); -} else { - x_931 = x_927; -} -lean_ctor_set(x_931, 0, x_925); -lean_ctor_set(x_931, 1, x_930); -x_932 = lean_st_ref_set(x_2, x_931, x_924); -lean_dec(x_2); -x_933 = lean_ctor_get(x_932, 1); -lean_inc(x_933); -if (lean_is_exclusive(x_932)) { - lean_ctor_release(x_932, 0); - lean_ctor_release(x_932, 1); - x_934 = x_932; -} else { - lean_dec_ref(x_932); - x_934 = lean_box(0); -} -if (lean_is_scalar(x_934)) { +if (lean_is_scalar(x_884)) { x_935 = lean_alloc_ctor(0, 2, 0); } else { - x_935 = x_934; + x_935 = x_884; } -lean_ctor_set(x_935, 0, x_918); -lean_ctor_set(x_935, 1, x_933); +lean_ctor_set(x_935, 0, x_1); +lean_ctor_set(x_935, 1, x_883); return x_935; } } else { -lean_object* x_936; uint8_t x_937; -lean_dec(x_785); +lean_object* x_936; +lean_dec(x_897); +lean_dec(x_869); lean_dec(x_10); -x_936 = l_Lean_Syntax_getArg(x_1, x_780); -x_937 = l_Lean_Syntax_isNone(x_936); -if (x_937 == 0) -{ -lean_object* x_938; lean_object* x_939; lean_object* x_940; lean_object* x_941; lean_object* x_942; lean_object* x_943; -lean_dec(x_1); -x_938 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; -x_939 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_936, x_938, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); lean_dec(x_8); lean_dec(x_6); lean_dec(x_5); lean_dec(x_4); -lean_dec(x_798); lean_dec(x_2); -lean_dec(x_936); -x_940 = lean_ctor_get(x_939, 0); -lean_inc(x_940); -x_941 = lean_ctor_get(x_939, 1); -lean_inc(x_941); -if (lean_is_exclusive(x_939)) { - lean_ctor_release(x_939, 0); - lean_ctor_release(x_939, 1); - x_942 = x_939; +if (lean_is_scalar(x_884)) { + x_936 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_939); - x_942 = lean_box(0); -} -if (lean_is_scalar(x_942)) { - x_943 = lean_alloc_ctor(1, 2, 0); -} else { - x_943 = x_942; -} -lean_ctor_set(x_943, 0, x_940); -lean_ctor_set(x_943, 1, x_941); -return x_943; -} -else -{ -lean_object* x_944; lean_object* x_945; -lean_dec(x_936); -x_944 = lean_box(0); -x_945 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_944, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -return x_945; + x_936 = x_884; } +lean_ctor_set(x_936, 0, x_1); +lean_ctor_set(x_936, 1, x_883); +return x_936; } } else { -lean_object* x_946; lean_object* x_947; lean_object* x_948; lean_object* x_949; -lean_dec(x_785); +lean_object* x_937; +lean_dec(x_897); +lean_dec(x_869); lean_dec(x_10); -x_946 = l_Lean_Syntax_getArg(x_1, x_780); -x_947 = l_Lean_Syntax_getArgs(x_946); -lean_dec(x_946); -x_948 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; -x_949 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_947, x_948, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -lean_dec(x_947); -if (lean_obj_tag(x_949) == 0) -{ -lean_object* x_950; lean_object* x_951; lean_object* x_952; lean_object* x_953; lean_object* x_954; lean_object* x_955; lean_object* x_956; -x_950 = lean_ctor_get(x_949, 0); -lean_inc(x_950); -x_951 = lean_ctor_get(x_949, 1); -lean_inc(x_951); -if (lean_is_exclusive(x_949)) { - lean_ctor_release(x_949, 0); - lean_ctor_release(x_949, 1); - x_952 = x_949; +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_884)) { + x_937 = lean_alloc_ctor(0, 2, 0); } else { - lean_dec_ref(x_949); - x_952 = lean_box(0); + x_937 = x_884; } -x_953 = l_Lean_nullKind; -x_954 = lean_alloc_ctor(1, 2, 0); -lean_ctor_set(x_954, 0, x_953); -lean_ctor_set(x_954, 1, x_950); -x_955 = l_Lean_Syntax_setArg(x_1, x_780, x_954); -if (lean_is_scalar(x_952)) { - x_956 = lean_alloc_ctor(0, 2, 0); -} else { - x_956 = x_952; +lean_ctor_set(x_937, 0, x_1); +lean_ctor_set(x_937, 1, x_883); +return x_937; } -lean_ctor_set(x_956, 0, x_955); -lean_ctor_set(x_956, 1, x_951); -return x_956; } else { -lean_object* x_957; lean_object* x_958; lean_object* x_959; lean_object* x_960; +lean_object* x_938; +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_884)) { + x_938 = lean_alloc_ctor(0, 2, 0); +} else { + x_938 = x_884; +} +lean_ctor_set(x_938, 0, x_1); +lean_ctor_set(x_938, 1, x_883); +return x_938; +} +} +else +{ +lean_object* x_939; +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_10); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_884)) { + x_939 = lean_alloc_ctor(0, 2, 0); +} else { + x_939 = x_884; +} +lean_ctor_set(x_939, 0, x_1); +lean_ctor_set(x_939, 1, x_883); +return x_939; +} +} +else +{ +lean_object* x_940; lean_object* x_941; lean_object* x_942; +lean_dec(x_884); +lean_dec(x_10); +x_940 = lean_unsigned_to_nat(2u); +x_941 = l_Lean_Syntax_getArg(x_1, x_940); +lean_inc(x_8); +lean_inc(x_869); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_897); +lean_inc(x_2); +x_942 = l_Lean_Elab_Term_CollectPatternVars_collect(x_941, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +if (lean_obj_tag(x_942) == 0) +{ +lean_object* x_943; lean_object* x_944; lean_object* x_945; lean_object* x_946; lean_object* x_947; +x_943 = lean_ctor_get(x_942, 0); +lean_inc(x_943); +x_944 = lean_ctor_get(x_942, 1); +lean_inc(x_944); +lean_dec(x_942); +x_945 = lean_unsigned_to_nat(3u); +x_946 = l_Lean_Syntax_getArg(x_1, x_945); +x_947 = l_Lean_Elab_Term_CollectPatternVars_collect(x_946, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_944); +if (lean_obj_tag(x_947) == 0) +{ +lean_object* x_948; lean_object* x_949; lean_object* x_950; lean_object* x_951; lean_object* x_952; lean_object* x_953; +x_948 = lean_ctor_get(x_947, 0); +lean_inc(x_948); +x_949 = lean_ctor_get(x_947, 1); +lean_inc(x_949); +if (lean_is_exclusive(x_947)) { + lean_ctor_release(x_947, 0); + lean_ctor_release(x_947, 1); + x_950 = x_947; +} else { + lean_dec_ref(x_947); + x_950 = lean_box(0); +} +x_951 = l_Lean_Syntax_setArg(x_1, x_940, x_943); +x_952 = l_Lean_Syntax_setArg(x_951, x_945, x_948); +if (lean_is_scalar(x_950)) { + x_953 = lean_alloc_ctor(0, 2, 0); +} else { + x_953 = x_950; +} +lean_ctor_set(x_953, 0, x_952); +lean_ctor_set(x_953, 1, x_949); +return x_953; +} +else +{ +lean_object* x_954; lean_object* x_955; lean_object* x_956; lean_object* x_957; +lean_dec(x_943); lean_dec(x_1); -x_957 = lean_ctor_get(x_949, 0); -lean_inc(x_957); -x_958 = lean_ctor_get(x_949, 1); +x_954 = lean_ctor_get(x_947, 0); +lean_inc(x_954); +x_955 = lean_ctor_get(x_947, 1); +lean_inc(x_955); +if (lean_is_exclusive(x_947)) { + lean_ctor_release(x_947, 0); + lean_ctor_release(x_947, 1); + x_956 = x_947; +} else { + lean_dec_ref(x_947); + x_956 = lean_box(0); +} +if (lean_is_scalar(x_956)) { + x_957 = lean_alloc_ctor(1, 2, 0); +} else { + x_957 = x_956; +} +lean_ctor_set(x_957, 0, x_954); +lean_ctor_set(x_957, 1, x_955); +return x_957; +} +} +else +{ +lean_object* x_958; lean_object* x_959; lean_object* x_960; lean_object* x_961; +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_958 = lean_ctor_get(x_942, 0); lean_inc(x_958); -if (lean_is_exclusive(x_949)) { - lean_ctor_release(x_949, 0); - lean_ctor_release(x_949, 1); - x_959 = x_949; +x_959 = lean_ctor_get(x_942, 1); +lean_inc(x_959); +if (lean_is_exclusive(x_942)) { + lean_ctor_release(x_942, 0); + lean_ctor_release(x_942, 1); + x_960 = x_942; } else { - lean_dec_ref(x_949); - x_959 = lean_box(0); + lean_dec_ref(x_942); + x_960 = lean_box(0); } -if (lean_is_scalar(x_959)) { - x_960 = lean_alloc_ctor(1, 2, 0); +if (lean_is_scalar(x_960)) { + x_961 = lean_alloc_ctor(1, 2, 0); } else { - x_960 = x_959; + x_961 = x_960; } -lean_ctor_set(x_960, 0, x_957); -lean_ctor_set(x_960, 1, x_958); -return x_960; -} -} -} -else -{ -lean_object* x_961; -lean_dec(x_785); -lean_dec(x_10); -x_961 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -lean_dec(x_1); +lean_ctor_set(x_961, 0, x_958); +lean_ctor_set(x_961, 1, x_959); return x_961; } } +} else { -lean_object* x_962; -lean_dec(x_785); +lean_object* x_962; lean_object* x_963; lean_object* x_964; +lean_dec(x_884); lean_dec(x_10); -x_962 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_798, x_4, x_5, x_6, x_770, x_8, x_784); -return x_962; +x_962 = lean_unsigned_to_nat(0u); +x_963 = l_Lean_Syntax_getArg(x_1, x_962); +lean_inc(x_869); +lean_inc(x_963); +x_964 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar(x_963, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +if (lean_obj_tag(x_964) == 0) +{ +lean_object* x_965; lean_object* x_966; lean_object* x_967; lean_object* x_968; +x_965 = lean_ctor_get(x_964, 1); +lean_inc(x_965); +lean_dec(x_964); +x_966 = lean_unsigned_to_nat(2u); +x_967 = l_Lean_Syntax_getArg(x_1, x_966); +lean_dec(x_1); +lean_inc(x_8); +lean_inc(x_869); +lean_inc(x_6); +lean_inc(x_5); +lean_inc(x_4); +lean_inc(x_897); +x_968 = l_Lean_Elab_Term_CollectPatternVars_collect(x_967, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_965); +if (lean_obj_tag(x_968) == 0) +{ +lean_object* x_969; lean_object* x_970; lean_object* x_971; lean_object* x_972; lean_object* x_973; lean_object* x_974; lean_object* x_975; lean_object* x_976; lean_object* x_977; lean_object* x_978; lean_object* x_979; lean_object* x_980; lean_object* x_981; lean_object* x_982; lean_object* x_983; lean_object* x_984; lean_object* x_985; lean_object* x_986; lean_object* x_987; lean_object* x_988; lean_object* x_989; lean_object* x_990; lean_object* x_991; lean_object* x_992; lean_object* x_993; lean_object* x_994; +x_969 = lean_ctor_get(x_968, 0); +lean_inc(x_969); +x_970 = lean_ctor_get(x_968, 1); +lean_inc(x_970); +lean_dec(x_968); +x_971 = l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Term_CollectPatternVars_collect___spec__1___rarg(x_869, x_8, x_970); +x_972 = lean_ctor_get(x_971, 0); +lean_inc(x_972); +x_973 = lean_ctor_get(x_971, 1); +lean_inc(x_973); +lean_dec(x_971); +x_974 = l_Lean_Elab_Term_getCurrMacroScope(x_897, x_4, x_5, x_6, x_869, x_8, x_973); +lean_dec(x_869); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_897); +x_975 = lean_ctor_get(x_974, 0); +lean_inc(x_975); +x_976 = lean_ctor_get(x_974, 1); +lean_inc(x_976); +lean_dec(x_974); +x_977 = l_Lean_Elab_Term_getMainModule___rarg(x_8, x_976); +lean_dec(x_8); +x_978 = lean_ctor_get(x_977, 0); +lean_inc(x_978); +x_979 = lean_ctor_get(x_977, 1); +lean_inc(x_979); +if (lean_is_exclusive(x_977)) { + lean_ctor_release(x_977, 0); + lean_ctor_release(x_977, 1); + x_980 = x_977; +} else { + lean_dec_ref(x_977); + x_980 = lean_box(0); +} +x_981 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__6; +x_982 = l_Lean_addMacroScope(x_978, x_981, x_975); +x_983 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__5; +x_984 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__9; +x_985 = lean_alloc_ctor(3, 4, 0); +lean_ctor_set(x_985, 0, x_972); +lean_ctor_set(x_985, 1, x_983); +lean_ctor_set(x_985, 2, x_982); +lean_ctor_set(x_985, 3, x_984); +x_986 = l_Array_empty___closed__1; +x_987 = lean_array_push(x_986, x_985); +x_988 = lean_array_push(x_986, x_963); +x_989 = lean_array_push(x_988, x_969); +x_990 = l_Lean_nullKind___closed__2; +x_991 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_991, 0, x_990); +lean_ctor_set(x_991, 1, x_989); +x_992 = lean_array_push(x_987, x_991); +x_993 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_993, 0, x_898); +lean_ctor_set(x_993, 1, x_992); +if (lean_is_scalar(x_980)) { + x_994 = lean_alloc_ctor(0, 2, 0); +} else { + x_994 = x_980; +} +lean_ctor_set(x_994, 0, x_993); +lean_ctor_set(x_994, 1, x_979); +return x_994; +} +else +{ +lean_object* x_995; lean_object* x_996; lean_object* x_997; lean_object* x_998; +lean_dec(x_963); +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +x_995 = lean_ctor_get(x_968, 0); +lean_inc(x_995); +x_996 = lean_ctor_get(x_968, 1); +lean_inc(x_996); +if (lean_is_exclusive(x_968)) { + lean_ctor_release(x_968, 0); + lean_ctor_release(x_968, 1); + x_997 = x_968; +} else { + lean_dec_ref(x_968); + x_997 = lean_box(0); +} +if (lean_is_scalar(x_997)) { + x_998 = lean_alloc_ctor(1, 2, 0); +} else { + x_998 = x_997; +} +lean_ctor_set(x_998, 0, x_995); +lean_ctor_set(x_998, 1, x_996); +return x_998; +} +} +else +{ +lean_object* x_999; lean_object* x_1000; lean_object* x_1001; lean_object* x_1002; +lean_dec(x_963); +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +lean_dec(x_1); +x_999 = lean_ctor_get(x_964, 0); +lean_inc(x_999); +x_1000 = lean_ctor_get(x_964, 1); +lean_inc(x_1000); +if (lean_is_exclusive(x_964)) { + lean_ctor_release(x_964, 0); + lean_ctor_release(x_964, 1); + x_1001 = x_964; +} else { + lean_dec_ref(x_964); + x_1001 = lean_box(0); +} +if (lean_is_scalar(x_1001)) { + x_1002 = lean_alloc_ctor(1, 2, 0); +} else { + x_1002 = x_1001; +} +lean_ctor_set(x_1002, 0, x_999); +lean_ctor_set(x_1002, 1, x_1000); +return x_1002; +} +} +} +else +{ +lean_object* x_1003; lean_object* x_1004; lean_object* x_1005; +lean_dec(x_884); +lean_dec(x_10); +x_1003 = lean_unsigned_to_nat(0u); +x_1004 = l_Lean_Syntax_getArg(x_1, x_1003); +lean_dec(x_1); +x_1005 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtor(x_1004, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +return x_1005; +} +} +else +{ +lean_object* x_1006; uint8_t x_1007; +lean_dec(x_10); +x_1006 = l_Lean_Syntax_getArg(x_1, x_879); +x_1007 = l_Lean_Syntax_isNone(x_1006); +if (x_1007 == 0) +{ +lean_object* x_1008; lean_object* x_1009; lean_object* x_1010; uint8_t x_1011; +x_1008 = lean_unsigned_to_nat(0u); +x_1009 = l_Lean_Syntax_getArg(x_1006, x_1008); +x_1010 = l_Lean_Syntax_getArg(x_1006, x_879); +x_1011 = l_Lean_Syntax_isNone(x_1010); +if (x_1011 == 0) +{ +lean_object* x_1012; lean_object* x_1013; lean_object* x_1014; uint8_t x_1015; +x_1012 = l_Lean_Syntax_getArg(x_1010, x_1008); +lean_dec(x_1010); +x_1013 = l_Lean_Syntax_getKind(x_1012); +x_1014 = l_myMacro____x40_Init_Notation___hyg_15036____closed__8; +x_1015 = lean_name_eq(x_1013, x_1014); +lean_dec(x_1013); +if (x_1015 == 0) +{ +lean_object* x_1016; +lean_dec(x_1009); +lean_dec(x_1006); +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_884)) { + x_1016 = lean_alloc_ctor(0, 2, 0); +} else { + x_1016 = x_884; +} +lean_ctor_set(x_1016, 0, x_1); +lean_ctor_set(x_1016, 1, x_883); +return x_1016; +} +else +{ +lean_object* x_1017; +lean_dec(x_884); +x_1017 = l_Lean_Elab_Term_CollectPatternVars_collect(x_1009, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +if (lean_obj_tag(x_1017) == 0) +{ +lean_object* x_1018; lean_object* x_1019; lean_object* x_1020; lean_object* x_1021; lean_object* x_1022; lean_object* x_1023; +x_1018 = lean_ctor_get(x_1017, 0); +lean_inc(x_1018); +x_1019 = lean_ctor_get(x_1017, 1); +lean_inc(x_1019); +if (lean_is_exclusive(x_1017)) { + lean_ctor_release(x_1017, 0); + lean_ctor_release(x_1017, 1); + x_1020 = x_1017; +} else { + lean_dec_ref(x_1017); + x_1020 = lean_box(0); +} +x_1021 = l_Lean_Syntax_setArg(x_1006, x_1008, x_1018); +x_1022 = l_Lean_Syntax_setArg(x_1, x_879, x_1021); +if (lean_is_scalar(x_1020)) { + x_1023 = lean_alloc_ctor(0, 2, 0); +} else { + x_1023 = x_1020; +} +lean_ctor_set(x_1023, 0, x_1022); +lean_ctor_set(x_1023, 1, x_1019); +return x_1023; +} +else +{ +lean_object* x_1024; lean_object* x_1025; lean_object* x_1026; lean_object* x_1027; +lean_dec(x_1006); +lean_dec(x_1); +x_1024 = lean_ctor_get(x_1017, 0); +lean_inc(x_1024); +x_1025 = lean_ctor_get(x_1017, 1); +lean_inc(x_1025); +if (lean_is_exclusive(x_1017)) { + lean_ctor_release(x_1017, 0); + lean_ctor_release(x_1017, 1); + x_1026 = x_1017; +} else { + lean_dec_ref(x_1017); + x_1026 = lean_box(0); +} +if (lean_is_scalar(x_1026)) { + x_1027 = lean_alloc_ctor(1, 2, 0); +} else { + x_1027 = x_1026; +} +lean_ctor_set(x_1027, 0, x_1024); +lean_ctor_set(x_1027, 1, x_1025); +return x_1027; +} +} +} +else +{ +lean_object* x_1028; +lean_dec(x_1010); +lean_dec(x_884); +x_1028 = l_Lean_Elab_Term_CollectPatternVars_collect(x_1009, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +if (lean_obj_tag(x_1028) == 0) +{ +lean_object* x_1029; lean_object* x_1030; lean_object* x_1031; lean_object* x_1032; lean_object* x_1033; lean_object* x_1034; +x_1029 = lean_ctor_get(x_1028, 0); +lean_inc(x_1029); +x_1030 = lean_ctor_get(x_1028, 1); +lean_inc(x_1030); +if (lean_is_exclusive(x_1028)) { + lean_ctor_release(x_1028, 0); + lean_ctor_release(x_1028, 1); + x_1031 = x_1028; +} else { + lean_dec_ref(x_1028); + x_1031 = lean_box(0); +} +x_1032 = l_Lean_Syntax_setArg(x_1006, x_1008, x_1029); +x_1033 = l_Lean_Syntax_setArg(x_1, x_879, x_1032); +if (lean_is_scalar(x_1031)) { + x_1034 = lean_alloc_ctor(0, 2, 0); +} else { + x_1034 = x_1031; +} +lean_ctor_set(x_1034, 0, x_1033); +lean_ctor_set(x_1034, 1, x_1030); +return x_1034; +} +else +{ +lean_object* x_1035; lean_object* x_1036; lean_object* x_1037; lean_object* x_1038; +lean_dec(x_1006); +lean_dec(x_1); +x_1035 = lean_ctor_get(x_1028, 0); +lean_inc(x_1035); +x_1036 = lean_ctor_get(x_1028, 1); +lean_inc(x_1036); +if (lean_is_exclusive(x_1028)) { + lean_ctor_release(x_1028, 0); + lean_ctor_release(x_1028, 1); + x_1037 = x_1028; +} else { + lean_dec_ref(x_1028); + x_1037 = lean_box(0); +} +if (lean_is_scalar(x_1037)) { + x_1038 = lean_alloc_ctor(1, 2, 0); +} else { + x_1038 = x_1037; +} +lean_ctor_set(x_1038, 0, x_1035); +lean_ctor_set(x_1038, 1, x_1036); +return x_1038; +} +} +} +else +{ +lean_object* x_1039; +lean_dec(x_1006); +lean_dec(x_897); +lean_dec(x_869); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_2); +if (lean_is_scalar(x_884)) { + x_1039 = lean_alloc_ctor(0, 2, 0); +} else { + x_1039 = x_884; +} +lean_ctor_set(x_1039, 0, x_1); +lean_ctor_set(x_1039, 1, x_883); +return x_1039; +} +} +} +else +{ +lean_object* x_1040; lean_object* x_1041; lean_object* x_1042; lean_object* x_1043; lean_object* x_1044; lean_object* x_1045; lean_object* x_1046; lean_object* x_1047; lean_object* x_1048; lean_object* x_1049; lean_object* x_1050; lean_object* x_1051; lean_object* x_1052; lean_object* x_1053; lean_object* x_1054; lean_object* x_1055; lean_object* x_1056; lean_object* x_1057; lean_object* x_1058; +lean_dec(x_897); +lean_dec(x_884); +lean_dec(x_869); +lean_dec(x_10); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_1); +x_1040 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_mkMVarSyntax___rarg(x_8, x_883); +x_1041 = lean_ctor_get(x_1040, 0); +lean_inc(x_1041); +x_1042 = lean_ctor_get(x_1040, 1); +lean_inc(x_1042); +lean_dec(x_1040); +x_1043 = lean_st_ref_get(x_8, x_1042); +lean_dec(x_8); +x_1044 = lean_ctor_get(x_1043, 1); +lean_inc(x_1044); +lean_dec(x_1043); +x_1045 = lean_st_ref_take(x_2, x_1044); +x_1046 = lean_ctor_get(x_1045, 0); +lean_inc(x_1046); +x_1047 = lean_ctor_get(x_1045, 1); +lean_inc(x_1047); +lean_dec(x_1045); +x_1048 = lean_ctor_get(x_1046, 0); +lean_inc(x_1048); +x_1049 = lean_ctor_get(x_1046, 1); +lean_inc(x_1049); +if (lean_is_exclusive(x_1046)) { + lean_ctor_release(x_1046, 0); + lean_ctor_release(x_1046, 1); + x_1050 = x_1046; +} else { + lean_dec_ref(x_1046); + x_1050 = lean_box(0); +} +x_1051 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_getMVarSyntaxMVarId(x_1041); +x_1052 = lean_alloc_ctor(1, 1, 0); +lean_ctor_set(x_1052, 0, x_1051); +x_1053 = lean_array_push(x_1049, x_1052); +if (lean_is_scalar(x_1050)) { + x_1054 = lean_alloc_ctor(0, 2, 0); +} else { + x_1054 = x_1050; +} +lean_ctor_set(x_1054, 0, x_1048); +lean_ctor_set(x_1054, 1, x_1053); +x_1055 = lean_st_ref_set(x_2, x_1054, x_1047); +lean_dec(x_2); +x_1056 = lean_ctor_get(x_1055, 1); +lean_inc(x_1056); +if (lean_is_exclusive(x_1055)) { + lean_ctor_release(x_1055, 0); + lean_ctor_release(x_1055, 1); + x_1057 = x_1055; +} else { + lean_dec_ref(x_1055); + x_1057 = lean_box(0); +} +if (lean_is_scalar(x_1057)) { + x_1058 = lean_alloc_ctor(0, 2, 0); +} else { + x_1058 = x_1057; +} +lean_ctor_set(x_1058, 0, x_1041); +lean_ctor_set(x_1058, 1, x_1056); +return x_1058; +} +} +else +{ +lean_object* x_1059; uint8_t x_1060; +lean_dec(x_884); +lean_dec(x_10); +x_1059 = l_Lean_Syntax_getArg(x_1, x_879); +x_1060 = l_Lean_Syntax_isNone(x_1059); +if (x_1060 == 0) +{ +lean_object* x_1061; lean_object* x_1062; lean_object* x_1063; lean_object* x_1064; lean_object* x_1065; lean_object* x_1066; +lean_dec(x_1); +x_1061 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__11; +x_1062 = l_Lean_throwErrorAt___at___private_Lean_Elab_Match_0__Lean_Elab_Term_CollectPatternVars_processVar___spec__2(x_1059, x_1061, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_8); +lean_dec(x_6); +lean_dec(x_5); +lean_dec(x_4); +lean_dec(x_897); +lean_dec(x_2); +lean_dec(x_1059); +x_1063 = lean_ctor_get(x_1062, 0); +lean_inc(x_1063); +x_1064 = lean_ctor_get(x_1062, 1); +lean_inc(x_1064); +if (lean_is_exclusive(x_1062)) { + lean_ctor_release(x_1062, 0); + lean_ctor_release(x_1062, 1); + x_1065 = x_1062; +} else { + lean_dec_ref(x_1062); + x_1065 = lean_box(0); +} +if (lean_is_scalar(x_1065)) { + x_1066 = lean_alloc_ctor(1, 2, 0); +} else { + x_1066 = x_1065; +} +lean_ctor_set(x_1066, 0, x_1063); +lean_ctor_set(x_1066, 1, x_1064); +return x_1066; +} +else +{ +lean_object* x_1067; lean_object* x_1068; +lean_dec(x_1059); +x_1067 = lean_box(0); +x_1068 = l_Lean_Elab_Term_CollectPatternVars_collect___lambda__1(x_1, x_1067, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +return x_1068; +} +} +} +else +{ +lean_object* x_1069; lean_object* x_1070; lean_object* x_1071; lean_object* x_1072; +lean_dec(x_884); +lean_dec(x_10); +x_1069 = l_Lean_Syntax_getArg(x_1, x_879); +x_1070 = l_Lean_Syntax_getArgs(x_1069); +lean_dec(x_1069); +x_1071 = l_Lean_Elab_Term_CollectPatternVars_collect___closed__12; +x_1072 = l_Array_mapSepElemsM___at_Lean_Elab_Term_CollectPatternVars_collect___spec__3(x_1070, x_1071, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_1070); +if (lean_obj_tag(x_1072) == 0) +{ +lean_object* x_1073; lean_object* x_1074; lean_object* x_1075; lean_object* x_1076; lean_object* x_1077; lean_object* x_1078; lean_object* x_1079; +x_1073 = lean_ctor_get(x_1072, 0); +lean_inc(x_1073); +x_1074 = lean_ctor_get(x_1072, 1); +lean_inc(x_1074); +if (lean_is_exclusive(x_1072)) { + lean_ctor_release(x_1072, 0); + lean_ctor_release(x_1072, 1); + x_1075 = x_1072; +} else { + lean_dec_ref(x_1072); + x_1075 = lean_box(0); +} +x_1076 = l_Lean_nullKind; +x_1077 = lean_alloc_ctor(1, 2, 0); +lean_ctor_set(x_1077, 0, x_1076); +lean_ctor_set(x_1077, 1, x_1073); +x_1078 = l_Lean_Syntax_setArg(x_1, x_879, x_1077); +if (lean_is_scalar(x_1075)) { + x_1079 = lean_alloc_ctor(0, 2, 0); +} else { + x_1079 = x_1075; +} +lean_ctor_set(x_1079, 0, x_1078); +lean_ctor_set(x_1079, 1, x_1074); +return x_1079; +} +else +{ +lean_object* x_1080; lean_object* x_1081; lean_object* x_1082; lean_object* x_1083; +lean_dec(x_1); +x_1080 = lean_ctor_get(x_1072, 0); +lean_inc(x_1080); +x_1081 = lean_ctor_get(x_1072, 1); +lean_inc(x_1081); +if (lean_is_exclusive(x_1072)) { + lean_ctor_release(x_1072, 0); + lean_ctor_release(x_1072, 1); + x_1082 = x_1072; +} else { + lean_dec_ref(x_1072); + x_1082 = lean_box(0); +} +if (lean_is_scalar(x_1082)) { + x_1083 = lean_alloc_ctor(1, 2, 0); +} else { + x_1083 = x_1082; +} +lean_ctor_set(x_1083, 0, x_1080); +lean_ctor_set(x_1083, 1, x_1081); +return x_1083; +} +} +} +else +{ +lean_object* x_1084; +lean_dec(x_884); +lean_dec(x_10); +x_1084 = l_Lean_Elab_Term_CollectPatternVars_collect_processCtorApp(x_1, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +lean_dec(x_1); +return x_1084; +} +} +else +{ +lean_object* x_1085; +lean_dec(x_884); +lean_dec(x_10); +x_1085 = l_Lean_Elab_Term_CollectPatternVars_collect_processId(x_1, x_2, x_897, x_4, x_5, x_6, x_869, x_8, x_883); +return x_1085; } } } @@ -31186,7 +31775,7 @@ lean_dec(x_5); return x_12; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; @@ -31196,7 +31785,7 @@ 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_Match___hyg_9295____closed__2() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__2() { _start: { lean_object* x_1; @@ -31204,17 +31793,17 @@ x_1 = lean_mk_string("ignoreUnusedAlts"); return x_1; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__3() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__3() { _start: { lean_object* x_1; lean_object* x_2; lean_object* x_3; -x_1 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1; -x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__2; +x_1 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1; +x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__2; 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_Match___hyg_9295____closed__4() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__4() { _start: { lean_object* x_1; @@ -31222,13 +31811,13 @@ x_1 = lean_mk_string("if true, do not generate error if an alternative is not us return x_1; } } -static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__5() { +static lean_object* _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____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 = 0; x_2 = l_Lean_instInhabitedParserDescr___closed__1; -x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__4; +x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__4; x_4 = lean_box(x_1); x_5 = lean_alloc_ctor(0, 3, 0); lean_ctor_set(x_5, 0, x_4); @@ -31237,12 +31826,12 @@ lean_ctor_set(x_5, 2, x_3); return x_5; } } -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295_(lean_object* x_1) { +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331_(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_Match___hyg_9295____closed__3; -x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__5; +x_2 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__3; +x_3 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__5; x_4 = l_Lean_Option_register___at_Lean_Elab_initFn____x40_Lean_Elab_AutoBound___hyg_4____spec__1(x_2, x_3, x_1); return x_4; } @@ -33268,7 +33857,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_Elab_Term_CollectPatternVars_collect_pushNewArg___closed__4; x_2 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_isMatchUnit_x3f___closed__3; -x_3 = lean_unsigned_to_nat(959u); +x_3 = lean_unsigned_to_nat(963u); x_4 = lean_unsigned_to_nat(2u); x_5 = l___private_Lean_Elab_Match_0__Lean_Elab_Term_isMatchUnit_x3f___closed__2; x_6 = l___private_Init_Util_0__mkPanicMessageWithDecl(x_1, x_2, x_3, x_4, x_5); @@ -35494,7 +36083,7 @@ x_31 = lean_ctor_get(x_29, 1); lean_inc(x_31); lean_dec(x_29); x_32 = lean_array_get_size(x_25); -x_33 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1; +x_33 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1; lean_inc(x_7); x_34 = l_Lean_Elab_Term_mkAuxName(x_33, x_7, x_8, x_9, x_10, x_11, x_12, x_31); if (lean_obj_tag(x_34) == 0) @@ -35900,7 +36489,7 @@ x_109 = lean_ctor_get(x_21, 1); lean_inc(x_109); lean_dec(x_21); x_110 = lean_array_get_size(x_106); -x_111 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1; +x_111 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1; lean_inc(x_7); x_112 = l_Lean_Elab_Term_mkAuxName(x_111, x_7, x_8, x_9, x_10, x_11, x_12, x_105); if (lean_obj_tag(x_112) == 0) @@ -39631,7 +40220,7 @@ x_5 = l_Lean_KeyedDeclsAttribute_addBuiltin___rarg(x_2, x_3, x_4, x_1); return x_5; } } -lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_12006_(lean_object* x_1) { +lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_12042_(lean_object* x_1) { _start: { lean_object* x_2; lean_object* x_3; @@ -40160,17 +40749,17 @@ l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_collectDeps___cl lean_mark_persistent(l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_collectDeps___closed__1); l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_loop___boxed__const__1 = _init_l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_loop___boxed__const__1(); lean_mark_persistent(l___private_Lean_Elab_Match_0__Lean_Elab_Term_elabMatchAltViews_loop___boxed__const__1); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__2(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__2); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__3(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__3); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__4(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__4); -l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__5 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__5(); -lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__5); -res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295_(lean_io_mk_world()); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__2 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__2(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__2); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__3 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__3(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__3); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__4 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__4(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__4); +l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__5 = _init_l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__5(); +lean_mark_persistent(l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__5); +res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331_(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; l_Lean_Elab_Term_match_ignoreUnusedAlts = lean_io_result_get_value(res); lean_mark_persistent(l_Lean_Elab_Term_match_ignoreUnusedAlts); @@ -40246,7 +40835,7 @@ lean_mark_persistent(l___regBuiltin_Lean_Elab_Term_elabMatch___closed__1); res = l___regBuiltin_Lean_Elab_Term_elabMatch(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_Match___hyg_12006_(lean_io_mk_world()); +res = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_12042_(lean_io_mk_world()); if (lean_io_result_is_error(res)) return res; lean_dec_ref(res); l_Lean_Elab_Term_elabNoMatch___closed__1 = _init_l_Lean_Elab_Term_elabNoMatch___closed__1(); diff --git a/stage0/stdlib/Lean/Elab/Tactic/Match.c b/stage0/stdlib/Lean/Elab/Tactic/Match.c index 3c6c3a18d6..893d223d01 100644 --- a/stage0/stdlib/Lean/Elab/Tactic/Match.c +++ b/stage0/stdlib/Lean/Elab/Tactic/Match.c @@ -40,11 +40,11 @@ lean_object* l_Lean_Elab_withMacroExpansionInfo___at_Lean_Elab_Tactic_adaptExpan lean_object* l_Lean_Elab_Tactic_AuxMatchTermState_cases___default; size_t l_USize_sub(size_t, size_t); extern lean_object* l_Array_empty___closed__1; +extern lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1; lean_object* lean_st_ref_get(lean_object*, lean_object*); lean_object* l_Lean_mkIdentFrom(lean_object*, lean_object*); lean_object* l___private_Lean_Elab_Tactic_Match_0__Lean_Elab_Tactic_mkAuxiliaryMatchTerm_match__1(lean_object*); lean_object* l_Array_foldlMUnsafe_fold___at_Lean_Elab_Tactic_evalEraseAuxDiscrs___spec__5___boxed(lean_object*, lean_object*, lean_object*, lean_object*); -extern lean_object* l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1; lean_object* l___private_Std_Data_PersistentArray_0__Std_PersistentArray_foldlFromMAux___at_Lean_Elab_Tactic_evalEraseAuxDiscrs___spec__3___boxed(lean_object*, lean_object*, lean_object*, lean_object*); lean_object* l_Lean_MonadRef_mkInfoFromRefPos___at_Lean_Elab_Tactic_evalIntro___spec__1___rarg(lean_object*, lean_object*, lean_object*); lean_object* lean_array_push(lean_object*, lean_object*); @@ -1593,7 +1593,7 @@ lean_dec(x_277); x_316 = lean_ctor_get(x_6, 0); lean_inc(x_316); lean_dec(x_6); -x_317 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9295____closed__1; +x_317 = l_Lean_Elab_Term_initFn____x40_Lean_Elab_Match___hyg_9331____closed__1; x_318 = l_Lean_Name_appendIndexAfter(x_317, x_316); x_319 = l_Lean_Name_append(x_1, x_318); x_320 = l_Lean_mkIdentFrom(x_30, x_319);